mocks

package

Go to main page

Versions in this module

v1

v1.0.0

Feb 20, 2026

Changes in this version

type AffectedComponentRepository

+ func (_mock *AffectedComponentRepository) CreateAffectedComponentsUsingUnnest(tx shared.DB, components []models.AffectedComponent) error

+ func (_mock *AffectedComponentRepository) SaveBatchBestEffort(tx shared.DB, ts []models.AffectedComponent) error

+ type AffectedComponentRepository_CreateAffectedComponentsUsingUnnest_Call struct

+ func (_c *AffectedComponentRepository_CreateAffectedComponentsUsingUnnest_Call) Return(err error) *AffectedComponentRepository_CreateAffectedComponentsUsingUnnest_Call

+ func (_c *AffectedComponentRepository_CreateAffectedComponentsUsingUnnest_Call) Run(run func(tx shared.DB, components []models.AffectedComponent)) *AffectedComponentRepository_CreateAffectedComponentsUsingUnnest_Call

+ func (_c *AffectedComponentRepository_CreateAffectedComponentsUsingUnnest_Call) RunAndReturn(run func(tx shared.DB, components []models.AffectedComponent) error) *AffectedComponentRepository_CreateAffectedComponentsUsingUnnest_Call

type AffectedComponentRepository_Expecter

+ func (_e *AffectedComponentRepository_Expecter) CreateAffectedComponentsUsingUnnest(tx interface{}, components interface{}) *AffectedComponentRepository_CreateAffectedComponentsUsingUnnest_Call

+ func (_e *AffectedComponentRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *AffectedComponentRepository_SaveBatchBestEffort_Call

+ type AffectedComponentRepository_SaveBatchBestEffort_Call struct

+ func (_c *AffectedComponentRepository_SaveBatchBestEffort_Call) Return(err error) *AffectedComponentRepository_SaveBatchBestEffort_Call

+ func (_c *AffectedComponentRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.AffectedComponent)) *AffectedComponentRepository_SaveBatchBestEffort_Call

+ func (_c *AffectedComponentRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.AffectedComponent) error) *AffectedComponentRepository_SaveBatchBestEffort_Call

type ArtifactRepository

+ func (_mock *ArtifactRepository) GetAllArtifactAffectedByDependencyVuln(tx shared.DB, vulnID string) ([]models.Artifact, error)

+ func (_mock *ArtifactRepository) GetByAssetVersions(assetID uuid.UUID, assetVersionNames []string) ([]models.Artifact, error)

+ func (_mock *ArtifactRepository) SaveBatchBestEffort(tx shared.DB, ts []models.Artifact) error

type ArtifactRepository_Expecter

+ func (_e *ArtifactRepository_Expecter) GetAllArtifactAffectedByDependencyVuln(tx interface{}, vulnID interface{}) *ArtifactRepository_GetAllArtifactAffectedByDependencyVuln_Call

+ func (_e *ArtifactRepository_Expecter) GetByAssetVersions(assetID interface{}, assetVersionNames interface{}) *ArtifactRepository_GetByAssetVersions_Call

+ func (_e *ArtifactRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *ArtifactRepository_SaveBatchBestEffort_Call

+ type ArtifactRepository_GetAllArtifactAffectedByDependencyVuln_Call struct

+ func (_c *ArtifactRepository_GetAllArtifactAffectedByDependencyVuln_Call) Return(artifacts []models.Artifact, err error) *ArtifactRepository_GetAllArtifactAffectedByDependencyVuln_Call

+ func (_c *ArtifactRepository_GetAllArtifactAffectedByDependencyVuln_Call) Run(run func(tx shared.DB, vulnID string)) *ArtifactRepository_GetAllArtifactAffectedByDependencyVuln_Call

+ func (_c *ArtifactRepository_GetAllArtifactAffectedByDependencyVuln_Call) RunAndReturn(run func(tx shared.DB, vulnID string) ([]models.Artifact, error)) *ArtifactRepository_GetAllArtifactAffectedByDependencyVuln_Call

+ type ArtifactRepository_GetByAssetVersions_Call struct

+ func (_c *ArtifactRepository_GetByAssetVersions_Call) Return(artifacts []models.Artifact, err error) *ArtifactRepository_GetByAssetVersions_Call

+ func (_c *ArtifactRepository_GetByAssetVersions_Call) Run(run func(assetID uuid.UUID, assetVersionNames []string)) *ArtifactRepository_GetByAssetVersions_Call

+ func (_c *ArtifactRepository_GetByAssetVersions_Call) RunAndReturn(...) *ArtifactRepository_GetByAssetVersions_Call

+ type ArtifactRepository_SaveBatchBestEffort_Call struct

+ func (_c *ArtifactRepository_SaveBatchBestEffort_Call) Return(err error) *ArtifactRepository_SaveBatchBestEffort_Call

+ func (_c *ArtifactRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.Artifact)) *ArtifactRepository_SaveBatchBestEffort_Call

+ func (_c *ArtifactRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.Artifact) error) *ArtifactRepository_SaveBatchBestEffort_Call

type ArtifactService

+ func (_mock *ArtifactService) GetArtifactsByAssetIDAndAssetVersionName(assetID uuid.UUID, assetVersionName string) ([]models.Artifact, error)

type ArtifactService_Expecter

+ func (_e *ArtifactService_Expecter) GetArtifactsByAssetIDAndAssetVersionName(assetID interface{}, assetVersionName interface{}) *ArtifactService_GetArtifactsByAssetIDAndAssetVersionName_Call

+ type ArtifactService_GetArtifactsByAssetIDAndAssetVersionName_Call struct

+ func (_c *ArtifactService_GetArtifactsByAssetIDAndAssetVersionName_Call) Return(artifacts []models.Artifact, err error) *ArtifactService_GetArtifactsByAssetIDAndAssetVersionName_Call

+ func (_c *ArtifactService_GetArtifactsByAssetIDAndAssetVersionName_Call) Run(run func(assetID uuid.UUID, assetVersionName string)) *ArtifactService_GetArtifactsByAssetIDAndAssetVersionName_Call

+ func (_c *ArtifactService_GetArtifactsByAssetIDAndAssetVersionName_Call) RunAndReturn(...) *ArtifactService_GetArtifactsByAssetIDAndAssetVersionName_Call

type AssetRepository

+ func (_mock *AssetRepository) GetAssetsWithVulnSharingEnabled(orgID uuid.UUID) ([]models.Asset, error)

+ func (_mock *AssetRepository) SaveBatchBestEffort(tx shared.DB, ts []models.Asset) error

type AssetRepository_Expecter

+ func (_e *AssetRepository_Expecter) GetAssetsWithVulnSharingEnabled(orgID interface{}) *AssetRepository_GetAssetsWithVulnSharingEnabled_Call

+ func (_e *AssetRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *AssetRepository_SaveBatchBestEffort_Call

+ type AssetRepository_GetAssetsWithVulnSharingEnabled_Call struct

+ func (_c *AssetRepository_GetAssetsWithVulnSharingEnabled_Call) Return(assets []models.Asset, err error) *AssetRepository_GetAssetsWithVulnSharingEnabled_Call

+ func (_c *AssetRepository_GetAssetsWithVulnSharingEnabled_Call) Run(run func(orgID uuid.UUID)) *AssetRepository_GetAssetsWithVulnSharingEnabled_Call

+ func (_c *AssetRepository_GetAssetsWithVulnSharingEnabled_Call) RunAndReturn(run func(orgID uuid.UUID) ([]models.Asset, error)) *AssetRepository_GetAssetsWithVulnSharingEnabled_Call

+ type AssetRepository_SaveBatchBestEffort_Call struct

+ func (_c *AssetRepository_SaveBatchBestEffort_Call) Return(err error) *AssetRepository_SaveBatchBestEffort_Call

+ func (_c *AssetRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.Asset)) *AssetRepository_SaveBatchBestEffort_Call

+ func (_c *AssetRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.Asset) error) *AssetRepository_SaveBatchBestEffort_Call

type AssetVersionRepository

+ func (_mock *AssetVersionRepository) Begin() shared.DB

+ func (_mock *AssetVersionRepository) DeleteOldAssetVersions(day int) (int64, error)

+ func (_mock *AssetVersionRepository) DeleteOldAssetVersionsOfAsset(assetID uuid.UUID, day int) (int64, error)

+ func (_mock *AssetVersionRepository) GetAllTagsAndDefaultBranchForAsset(tx shared.DB, assetID uuid.UUID) ([]models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) GetAssetVersionsByAssetID(tx shared.DB, assetID uuid.UUID) ([]models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) GetAssetVersionsByAssetIDWithArtifacts(tx shared.DB, assetID uuid.UUID) ([]models.AssetVersion, error)

+ type AssetVersionRepository_Begin_Call struct

+ func (_c *AssetVersionRepository_Begin_Call) Return(v shared.DB) *AssetVersionRepository_Begin_Call

+ func (_c *AssetVersionRepository_Begin_Call) Run(run func()) *AssetVersionRepository_Begin_Call

+ func (_c *AssetVersionRepository_Begin_Call) RunAndReturn(run func() shared.DB) *AssetVersionRepository_Begin_Call

+ type AssetVersionRepository_DeleteOldAssetVersionsOfAsset_Call struct

+ func (_c *AssetVersionRepository_DeleteOldAssetVersionsOfAsset_Call) Return(n int64, err error) *AssetVersionRepository_DeleteOldAssetVersionsOfAsset_Call

+ func (_c *AssetVersionRepository_DeleteOldAssetVersionsOfAsset_Call) Run(run func(assetID uuid.UUID, day int)) *AssetVersionRepository_DeleteOldAssetVersionsOfAsset_Call

+ func (_c *AssetVersionRepository_DeleteOldAssetVersionsOfAsset_Call) RunAndReturn(run func(assetID uuid.UUID, day int) (int64, error)) *AssetVersionRepository_DeleteOldAssetVersionsOfAsset_Call

+ type AssetVersionRepository_DeleteOldAssetVersions_Call struct

+ func (_c *AssetVersionRepository_DeleteOldAssetVersions_Call) Return(n int64, err error) *AssetVersionRepository_DeleteOldAssetVersions_Call

+ func (_c *AssetVersionRepository_DeleteOldAssetVersions_Call) Run(run func(day int)) *AssetVersionRepository_DeleteOldAssetVersions_Call

+ func (_c *AssetVersionRepository_DeleteOldAssetVersions_Call) RunAndReturn(run func(day int) (int64, error)) *AssetVersionRepository_DeleteOldAssetVersions_Call

type AssetVersionRepository_Expecter

+ func (_e *AssetVersionRepository_Expecter) Begin() *AssetVersionRepository_Begin_Call

+ func (_e *AssetVersionRepository_Expecter) DeleteOldAssetVersions(day interface{}) *AssetVersionRepository_DeleteOldAssetVersions_Call

+ func (_e *AssetVersionRepository_Expecter) DeleteOldAssetVersionsOfAsset(assetID interface{}, day interface{}) *AssetVersionRepository_DeleteOldAssetVersionsOfAsset_Call

+ func (_e *AssetVersionRepository_Expecter) GetAllTagsAndDefaultBranchForAsset(tx interface{}, assetID interface{}) *AssetVersionRepository_GetAllTagsAndDefaultBranchForAsset_Call

+ func (_e *AssetVersionRepository_Expecter) GetAssetVersionsByAssetID(tx interface{}, assetID interface{}) *AssetVersionRepository_GetAssetVersionsByAssetID_Call

+ func (_e *AssetVersionRepository_Expecter) GetAssetVersionsByAssetIDWithArtifacts(tx interface{}, assetID interface{}) *AssetVersionRepository_GetAssetVersionsByAssetIDWithArtifacts_Call

+ type AssetVersionRepository_GetAllTagsAndDefaultBranchForAsset_Call struct

+ func (_c *AssetVersionRepository_GetAllTagsAndDefaultBranchForAsset_Call) Return(assetVersions []models.AssetVersion, err error) *AssetVersionRepository_GetAllTagsAndDefaultBranchForAsset_Call

+ func (_c *AssetVersionRepository_GetAllTagsAndDefaultBranchForAsset_Call) Run(run func(tx shared.DB, assetID uuid.UUID)) *AssetVersionRepository_GetAllTagsAndDefaultBranchForAsset_Call

+ func (_c *AssetVersionRepository_GetAllTagsAndDefaultBranchForAsset_Call) RunAndReturn(run func(tx shared.DB, assetID uuid.UUID) ([]models.AssetVersion, error)) *AssetVersionRepository_GetAllTagsAndDefaultBranchForAsset_Call

+ type AssetVersionRepository_GetAssetVersionsByAssetIDWithArtifacts_Call struct

+ func (_c *AssetVersionRepository_GetAssetVersionsByAssetIDWithArtifacts_Call) Return(assetVersions []models.AssetVersion, err error) *AssetVersionRepository_GetAssetVersionsByAssetIDWithArtifacts_Call

+ func (_c *AssetVersionRepository_GetAssetVersionsByAssetIDWithArtifacts_Call) Run(run func(tx shared.DB, assetID uuid.UUID)) *AssetVersionRepository_GetAssetVersionsByAssetIDWithArtifacts_Call

+ func (_c *AssetVersionRepository_GetAssetVersionsByAssetIDWithArtifacts_Call) RunAndReturn(run func(tx shared.DB, assetID uuid.UUID) ([]models.AssetVersion, error)) *AssetVersionRepository_GetAssetVersionsByAssetIDWithArtifacts_Call

+ type AssetVersionRepository_GetAssetVersionsByAssetID_Call struct

+ func (_c *AssetVersionRepository_GetAssetVersionsByAssetID_Call) Return(assetVersions []models.AssetVersion, err error) *AssetVersionRepository_GetAssetVersionsByAssetID_Call

+ func (_c *AssetVersionRepository_GetAssetVersionsByAssetID_Call) Run(run func(tx shared.DB, assetID uuid.UUID)) *AssetVersionRepository_GetAssetVersionsByAssetID_Call

+ func (_c *AssetVersionRepository_GetAssetVersionsByAssetID_Call) RunAndReturn(run func(tx shared.DB, assetID uuid.UUID) ([]models.AssetVersion, error)) *AssetVersionRepository_GetAssetVersionsByAssetID_Call

type AssetVersionService

+ func (_mock *AssetVersionService) LoadFullSBOMGraph(assetVersion models.AssetVersion) (*normalize.SBOMGraph, error)

type AssetVersionService_Expecter

+ func (_e *AssetVersionService_Expecter) LoadFullSBOMGraph(assetVersion interface{}) *AssetVersionService_LoadFullSBOMGraph_Call

+ type AssetVersionService_LoadFullSBOMGraph_Call struct

+ func (_c *AssetVersionService_LoadFullSBOMGraph_Call) Return(sBOMGraph *normalize.SBOMGraph, err error) *AssetVersionService_LoadFullSBOMGraph_Call

+ func (_c *AssetVersionService_LoadFullSBOMGraph_Call) Run(run func(assetVersion models.AssetVersion)) *AssetVersionService_LoadFullSBOMGraph_Call

+ func (_c *AssetVersionService_LoadFullSBOMGraph_Call) RunAndReturn(run func(assetVersion models.AssetVersion) (*normalize.SBOMGraph, error)) *AssetVersionService_LoadFullSBOMGraph_Call

type AttestationRepository

+ func (_mock *AttestationRepository) SaveBatchBestEffort(tx shared.DB, ts []models.Attestation) error

type AttestationRepository_Expecter

+ func (_e *AttestationRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *AttestationRepository_SaveBatchBestEffort_Call

+ type AttestationRepository_SaveBatchBestEffort_Call struct

+ func (_c *AttestationRepository_SaveBatchBestEffort_Call) Return(err error) *AttestationRepository_SaveBatchBestEffort_Call

+ func (_c *AttestationRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.Attestation)) *AttestationRepository_SaveBatchBestEffort_Call

+ func (_c *AttestationRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.Attestation) error) *AttestationRepository_SaveBatchBestEffort_Call

+ type BatchModelWriter struct

+ func NewBatchModelWriter[T utils.Tabler, Tx any](t interface{ ... }) *BatchModelWriter[T, Tx]

+ func (_m *BatchModelWriter[T, Tx]) EXPECT() *BatchModelWriter_Expecter[T, Tx]

+ func (_mock *BatchModelWriter[T, Tx]) CreateBatch(tx Tx, ts []T) error

+ func (_mock *BatchModelWriter[T, Tx]) DeleteBatch(tx Tx, ids []T) error

+ func (_mock *BatchModelWriter[T, Tx]) SaveBatch(tx Tx, ts []T) error

+ func (_mock *BatchModelWriter[T, Tx]) SaveBatchBestEffort(tx Tx, ts []T) error

+ type BatchModelWriter_CreateBatch_Call struct

+ func (_c *BatchModelWriter_CreateBatch_Call[T, Tx]) Return(err error) *BatchModelWriter_CreateBatch_Call[T, Tx]

+ func (_c *BatchModelWriter_CreateBatch_Call[T, Tx]) Run(run func(tx Tx, ts []T)) *BatchModelWriter_CreateBatch_Call[T, Tx]

+ func (_c *BatchModelWriter_CreateBatch_Call[T, Tx]) RunAndReturn(run func(tx Tx, ts []T) error) *BatchModelWriter_CreateBatch_Call[T, Tx]

+ type BatchModelWriter_DeleteBatch_Call struct

+ func (_c *BatchModelWriter_DeleteBatch_Call[T, Tx]) Return(err error) *BatchModelWriter_DeleteBatch_Call[T, Tx]

+ func (_c *BatchModelWriter_DeleteBatch_Call[T, Tx]) Run(run func(tx Tx, ids []T)) *BatchModelWriter_DeleteBatch_Call[T, Tx]

+ func (_c *BatchModelWriter_DeleteBatch_Call[T, Tx]) RunAndReturn(run func(tx Tx, ids []T) error) *BatchModelWriter_DeleteBatch_Call[T, Tx]

+ type BatchModelWriter_Expecter struct

+ func (_e *BatchModelWriter_Expecter[T, Tx]) CreateBatch(tx interface{}, ts interface{}) *BatchModelWriter_CreateBatch_Call[T, Tx]

+ func (_e *BatchModelWriter_Expecter[T, Tx]) DeleteBatch(tx interface{}, ids interface{}) *BatchModelWriter_DeleteBatch_Call[T, Tx]

+ func (_e *BatchModelWriter_Expecter[T, Tx]) SaveBatch(tx interface{}, ts interface{}) *BatchModelWriter_SaveBatch_Call[T, Tx]

+ func (_e *BatchModelWriter_Expecter[T, Tx]) SaveBatchBestEffort(tx interface{}, ts interface{}) *BatchModelWriter_SaveBatchBestEffort_Call[T, Tx]

+ type BatchModelWriter_SaveBatchBestEffort_Call struct

+ func (_c *BatchModelWriter_SaveBatchBestEffort_Call[T, Tx]) Return(err error) *BatchModelWriter_SaveBatchBestEffort_Call[T, Tx]

+ func (_c *BatchModelWriter_SaveBatchBestEffort_Call[T, Tx]) Run(run func(tx Tx, ts []T)) *BatchModelWriter_SaveBatchBestEffort_Call[T, Tx]

+ func (_c *BatchModelWriter_SaveBatchBestEffort_Call[T, Tx]) RunAndReturn(run func(tx Tx, ts []T) error) *BatchModelWriter_SaveBatchBestEffort_Call[T, Tx]

+ type BatchModelWriter_SaveBatch_Call struct

+ func (_c *BatchModelWriter_SaveBatch_Call[T, Tx]) Return(err error) *BatchModelWriter_SaveBatch_Call[T, Tx]

+ func (_c *BatchModelWriter_SaveBatch_Call[T, Tx]) Run(run func(tx Tx, ts []T)) *BatchModelWriter_SaveBatch_Call[T, Tx]

+ func (_c *BatchModelWriter_SaveBatch_Call[T, Tx]) RunAndReturn(run func(tx Tx, ts []T) error) *BatchModelWriter_SaveBatch_Call[T, Tx]

+ type CSAFService struct

+ func NewCSAFService(t interface{ ... }) *CSAFService

+ func (_m *CSAFService) EXPECT() *CSAFService_Expecter

+ func (_mock *CSAFService) GetVexFromCsafProvider(purl packageurl.PackageURL, domain string) (*cyclonedx.BOM, error)

+ type CSAFService_Expecter struct

+ func (_e *CSAFService_Expecter) GetVexFromCsafProvider(purl interface{}, domain interface{}) *CSAFService_GetVexFromCsafProvider_Call

+ type CSAFService_GetVexFromCsafProvider_Call struct

+ func (_c *CSAFService_GetVexFromCsafProvider_Call) Return(bOM *cyclonedx.BOM, err error) *CSAFService_GetVexFromCsafProvider_Call

+ func (_c *CSAFService_GetVexFromCsafProvider_Call) Run(run func(purl packageurl.PackageURL, domain string)) *CSAFService_GetVexFromCsafProvider_Call

+ func (_c *CSAFService_GetVexFromCsafProvider_Call) RunAndReturn(run func(purl packageurl.PackageURL, domain string) (*cyclonedx.BOM, error)) *CSAFService_GetVexFromCsafProvider_Call

+ type CVERelationshipRepository struct

+ func NewCVERelationshipRepository(t interface{ ... }) *CVERelationshipRepository

+ func (_m *CVERelationshipRepository) EXPECT() *CVERelationshipRepository_Expecter

+ func (_mock *CVERelationshipRepository) Activate(tx shared.DB, id string) error

+ func (_mock *CVERelationshipRepository) All() ([]models.CVERelationship, error)

+ func (_mock *CVERelationshipRepository) Begin() shared.DB

+ func (_mock *CVERelationshipRepository) Create(tx shared.DB, t *models.CVERelationship) error

+ func (_mock *CVERelationshipRepository) CreateBatch(tx shared.DB, ts []models.CVERelationship) error

+ func (_mock *CVERelationshipRepository) Delete(tx shared.DB, id string) error

+ func (_mock *CVERelationshipRepository) DeleteBatch(tx shared.DB, ids []models.CVERelationship) error

+ func (_mock *CVERelationshipRepository) FilterOutRelationsWithInvalidTargetCVE(tx shared.DB) error

+ func (_mock *CVERelationshipRepository) GetAllRelationsForCVE(tx shared.DB, targetCVEID string) ([]models.CVERelationship, error)

+ func (_mock *CVERelationshipRepository) GetAllRelationshipsForCVEBatch(tx shared.DB, sourceCVEIDs []string) ([]models.CVERelationship, error)

+ func (_mock *CVERelationshipRepository) GetDB(tx shared.DB) shared.DB

+ func (_mock *CVERelationshipRepository) GetRelationshipsByTargetCVEBatch(tx shared.DB, targetCVEIDs []string) ([]models.CVERelationship, error)

+ func (_mock *CVERelationshipRepository) List(ids []string) ([]models.CVERelationship, error)

+ func (_mock *CVERelationshipRepository) Read(id string) (models.CVERelationship, error)

+ func (_mock *CVERelationshipRepository) Save(tx shared.DB, t *models.CVERelationship) error

+ func (_mock *CVERelationshipRepository) SaveBatch(tx shared.DB, ts []models.CVERelationship) error

+ func (_mock *CVERelationshipRepository) SaveBatchBestEffort(tx shared.DB, ts []models.CVERelationship) error

+ func (_mock *CVERelationshipRepository) Transaction(fn func(tx shared.DB) error) error

+ func (_mock *CVERelationshipRepository) Upsert(t *[]*models.CVERelationship, conflictingColumns []clause.Column, ...) error

+ type CVERelationshipRepository_Activate_Call struct

+ func (_c *CVERelationshipRepository_Activate_Call) Return(err error) *CVERelationshipRepository_Activate_Call

+ func (_c *CVERelationshipRepository_Activate_Call) Run(run func(tx shared.DB, id string)) *CVERelationshipRepository_Activate_Call

+ func (_c *CVERelationshipRepository_Activate_Call) RunAndReturn(run func(tx shared.DB, id string) error) *CVERelationshipRepository_Activate_Call

+ type CVERelationshipRepository_All_Call struct

+ func (_c *CVERelationshipRepository_All_Call) Return(cVERelationships []models.CVERelationship, err error) *CVERelationshipRepository_All_Call

+ func (_c *CVERelationshipRepository_All_Call) Run(run func()) *CVERelationshipRepository_All_Call

+ func (_c *CVERelationshipRepository_All_Call) RunAndReturn(run func() ([]models.CVERelationship, error)) *CVERelationshipRepository_All_Call

+ type CVERelationshipRepository_Begin_Call struct

+ func (_c *CVERelationshipRepository_Begin_Call) Return(v shared.DB) *CVERelationshipRepository_Begin_Call

+ func (_c *CVERelationshipRepository_Begin_Call) Run(run func()) *CVERelationshipRepository_Begin_Call

+ func (_c *CVERelationshipRepository_Begin_Call) RunAndReturn(run func() shared.DB) *CVERelationshipRepository_Begin_Call

+ type CVERelationshipRepository_CreateBatch_Call struct

+ func (_c *CVERelationshipRepository_CreateBatch_Call) Return(err error) *CVERelationshipRepository_CreateBatch_Call

+ func (_c *CVERelationshipRepository_CreateBatch_Call) Run(run func(tx shared.DB, ts []models.CVERelationship)) *CVERelationshipRepository_CreateBatch_Call

+ func (_c *CVERelationshipRepository_CreateBatch_Call) RunAndReturn(run func(tx shared.DB, ts []models.CVERelationship) error) *CVERelationshipRepository_CreateBatch_Call

+ type CVERelationshipRepository_Create_Call struct

+ func (_c *CVERelationshipRepository_Create_Call) Return(err error) *CVERelationshipRepository_Create_Call

+ func (_c *CVERelationshipRepository_Create_Call) Run(run func(tx shared.DB, t *models.CVERelationship)) *CVERelationshipRepository_Create_Call

+ func (_c *CVERelationshipRepository_Create_Call) RunAndReturn(run func(tx shared.DB, t *models.CVERelationship) error) *CVERelationshipRepository_Create_Call

+ type CVERelationshipRepository_DeleteBatch_Call struct

+ func (_c *CVERelationshipRepository_DeleteBatch_Call) Return(err error) *CVERelationshipRepository_DeleteBatch_Call

+ func (_c *CVERelationshipRepository_DeleteBatch_Call) Run(run func(tx shared.DB, ids []models.CVERelationship)) *CVERelationshipRepository_DeleteBatch_Call

+ func (_c *CVERelationshipRepository_DeleteBatch_Call) RunAndReturn(run func(tx shared.DB, ids []models.CVERelationship) error) *CVERelationshipRepository_DeleteBatch_Call

+ type CVERelationshipRepository_Delete_Call struct

+ func (_c *CVERelationshipRepository_Delete_Call) Return(err error) *CVERelationshipRepository_Delete_Call

+ func (_c *CVERelationshipRepository_Delete_Call) Run(run func(tx shared.DB, id string)) *CVERelationshipRepository_Delete_Call

+ func (_c *CVERelationshipRepository_Delete_Call) RunAndReturn(run func(tx shared.DB, id string) error) *CVERelationshipRepository_Delete_Call

+ type CVERelationshipRepository_Expecter struct

+ func (_e *CVERelationshipRepository_Expecter) Activate(tx interface{}, id interface{}) *CVERelationshipRepository_Activate_Call

+ func (_e *CVERelationshipRepository_Expecter) All() *CVERelationshipRepository_All_Call

+ func (_e *CVERelationshipRepository_Expecter) Begin() *CVERelationshipRepository_Begin_Call

+ func (_e *CVERelationshipRepository_Expecter) Create(tx interface{}, t interface{}) *CVERelationshipRepository_Create_Call

+ func (_e *CVERelationshipRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *CVERelationshipRepository_CreateBatch_Call

+ func (_e *CVERelationshipRepository_Expecter) Delete(tx interface{}, id interface{}) *CVERelationshipRepository_Delete_Call

+ func (_e *CVERelationshipRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *CVERelationshipRepository_DeleteBatch_Call

+ func (_e *CVERelationshipRepository_Expecter) FilterOutRelationsWithInvalidTargetCVE(tx interface{}) *CVERelationshipRepository_FilterOutRelationsWithInvalidTargetCVE_Call

+ func (_e *CVERelationshipRepository_Expecter) GetAllRelationsForCVE(tx interface{}, targetCVEID interface{}) *CVERelationshipRepository_GetAllRelationsForCVE_Call

+ func (_e *CVERelationshipRepository_Expecter) GetAllRelationshipsForCVEBatch(tx interface{}, sourceCVEIDs interface{}) *CVERelationshipRepository_GetAllRelationshipsForCVEBatch_Call

+ func (_e *CVERelationshipRepository_Expecter) GetDB(tx interface{}) *CVERelationshipRepository_GetDB_Call

+ func (_e *CVERelationshipRepository_Expecter) GetRelationshipsByTargetCVEBatch(tx interface{}, targetCVEIDs interface{}) *CVERelationshipRepository_GetRelationshipsByTargetCVEBatch_Call

+ func (_e *CVERelationshipRepository_Expecter) List(ids interface{}) *CVERelationshipRepository_List_Call

+ func (_e *CVERelationshipRepository_Expecter) Read(id interface{}) *CVERelationshipRepository_Read_Call

+ func (_e *CVERelationshipRepository_Expecter) Save(tx interface{}, t interface{}) *CVERelationshipRepository_Save_Call

+ func (_e *CVERelationshipRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *CVERelationshipRepository_SaveBatch_Call

+ func (_e *CVERelationshipRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *CVERelationshipRepository_SaveBatchBestEffort_Call

+ func (_e *CVERelationshipRepository_Expecter) Transaction(fn interface{}) *CVERelationshipRepository_Transaction_Call

+ func (_e *CVERelationshipRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *CVERelationshipRepository_Upsert_Call

+ type CVERelationshipRepository_FilterOutRelationsWithInvalidTargetCVE_Call struct

+ func (_c *CVERelationshipRepository_FilterOutRelationsWithInvalidTargetCVE_Call) Return(err error) *CVERelationshipRepository_FilterOutRelationsWithInvalidTargetCVE_Call

+ func (_c *CVERelationshipRepository_FilterOutRelationsWithInvalidTargetCVE_Call) Run(run func(tx shared.DB)) *CVERelationshipRepository_FilterOutRelationsWithInvalidTargetCVE_Call

+ func (_c *CVERelationshipRepository_FilterOutRelationsWithInvalidTargetCVE_Call) RunAndReturn(run func(tx shared.DB) error) *CVERelationshipRepository_FilterOutRelationsWithInvalidTargetCVE_Call

+ type CVERelationshipRepository_GetAllRelationsForCVE_Call struct

+ func (_c *CVERelationshipRepository_GetAllRelationsForCVE_Call) Return(cVERelationships []models.CVERelationship, err error) *CVERelationshipRepository_GetAllRelationsForCVE_Call

+ func (_c *CVERelationshipRepository_GetAllRelationsForCVE_Call) Run(run func(tx shared.DB, targetCVEID string)) *CVERelationshipRepository_GetAllRelationsForCVE_Call

+ func (_c *CVERelationshipRepository_GetAllRelationsForCVE_Call) RunAndReturn(run func(tx shared.DB, targetCVEID string) ([]models.CVERelationship, error)) *CVERelationshipRepository_GetAllRelationsForCVE_Call

+ type CVERelationshipRepository_GetAllRelationshipsForCVEBatch_Call struct

+ func (_c *CVERelationshipRepository_GetAllRelationshipsForCVEBatch_Call) Return(cVERelationships []models.CVERelationship, err error) *CVERelationshipRepository_GetAllRelationshipsForCVEBatch_Call

+ func (_c *CVERelationshipRepository_GetAllRelationshipsForCVEBatch_Call) Run(run func(tx shared.DB, sourceCVEIDs []string)) *CVERelationshipRepository_GetAllRelationshipsForCVEBatch_Call

+ func (_c *CVERelationshipRepository_GetAllRelationshipsForCVEBatch_Call) RunAndReturn(...) *CVERelationshipRepository_GetAllRelationshipsForCVEBatch_Call

+ type CVERelationshipRepository_GetDB_Call struct

+ func (_c *CVERelationshipRepository_GetDB_Call) Return(v shared.DB) *CVERelationshipRepository_GetDB_Call

+ func (_c *CVERelationshipRepository_GetDB_Call) Run(run func(tx shared.DB)) *CVERelationshipRepository_GetDB_Call

+ func (_c *CVERelationshipRepository_GetDB_Call) RunAndReturn(run func(tx shared.DB) shared.DB) *CVERelationshipRepository_GetDB_Call

+ type CVERelationshipRepository_GetRelationshipsByTargetCVEBatch_Call struct

+ func (_c *CVERelationshipRepository_GetRelationshipsByTargetCVEBatch_Call) Return(cVERelationships []models.CVERelationship, err error) *CVERelationshipRepository_GetRelationshipsByTargetCVEBatch_Call

+ func (_c *CVERelationshipRepository_GetRelationshipsByTargetCVEBatch_Call) Run(run func(tx shared.DB, targetCVEIDs []string)) *CVERelationshipRepository_GetRelationshipsByTargetCVEBatch_Call

+ func (_c *CVERelationshipRepository_GetRelationshipsByTargetCVEBatch_Call) RunAndReturn(...) *CVERelationshipRepository_GetRelationshipsByTargetCVEBatch_Call

+ type CVERelationshipRepository_List_Call struct

+ func (_c *CVERelationshipRepository_List_Call) Return(cVERelationships []models.CVERelationship, err error) *CVERelationshipRepository_List_Call

+ func (_c *CVERelationshipRepository_List_Call) Run(run func(ids []string)) *CVERelationshipRepository_List_Call

+ func (_c *CVERelationshipRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.CVERelationship, error)) *CVERelationshipRepository_List_Call

+ type CVERelationshipRepository_Read_Call struct

+ func (_c *CVERelationshipRepository_Read_Call) Return(cVERelationship models.CVERelationship, err error) *CVERelationshipRepository_Read_Call

+ func (_c *CVERelationshipRepository_Read_Call) Run(run func(id string)) *CVERelationshipRepository_Read_Call

+ func (_c *CVERelationshipRepository_Read_Call) RunAndReturn(run func(id string) (models.CVERelationship, error)) *CVERelationshipRepository_Read_Call

+ type CVERelationshipRepository_SaveBatchBestEffort_Call struct

+ func (_c *CVERelationshipRepository_SaveBatchBestEffort_Call) Return(err error) *CVERelationshipRepository_SaveBatchBestEffort_Call

+ func (_c *CVERelationshipRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.CVERelationship)) *CVERelationshipRepository_SaveBatchBestEffort_Call

+ func (_c *CVERelationshipRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.CVERelationship) error) *CVERelationshipRepository_SaveBatchBestEffort_Call

+ type CVERelationshipRepository_SaveBatch_Call struct

+ func (_c *CVERelationshipRepository_SaveBatch_Call) Return(err error) *CVERelationshipRepository_SaveBatch_Call

+ func (_c *CVERelationshipRepository_SaveBatch_Call) Run(run func(tx shared.DB, ts []models.CVERelationship)) *CVERelationshipRepository_SaveBatch_Call

+ func (_c *CVERelationshipRepository_SaveBatch_Call) RunAndReturn(run func(tx shared.DB, ts []models.CVERelationship) error) *CVERelationshipRepository_SaveBatch_Call

+ type CVERelationshipRepository_Save_Call struct

+ func (_c *CVERelationshipRepository_Save_Call) Return(err error) *CVERelationshipRepository_Save_Call

+ func (_c *CVERelationshipRepository_Save_Call) Run(run func(tx shared.DB, t *models.CVERelationship)) *CVERelationshipRepository_Save_Call

+ func (_c *CVERelationshipRepository_Save_Call) RunAndReturn(run func(tx shared.DB, t *models.CVERelationship) error) *CVERelationshipRepository_Save_Call

+ type CVERelationshipRepository_Transaction_Call struct

+ func (_c *CVERelationshipRepository_Transaction_Call) Return(err error) *CVERelationshipRepository_Transaction_Call

+ func (_c *CVERelationshipRepository_Transaction_Call) Run(run func(fn func(tx shared.DB) error)) *CVERelationshipRepository_Transaction_Call

+ func (_c *CVERelationshipRepository_Transaction_Call) RunAndReturn(run func(fn func(tx shared.DB) error) error) *CVERelationshipRepository_Transaction_Call

+ type CVERelationshipRepository_Upsert_Call struct

+ func (_c *CVERelationshipRepository_Upsert_Call) Return(err error) *CVERelationshipRepository_Upsert_Call

+ func (_c *CVERelationshipRepository_Upsert_Call) Run(...) *CVERelationshipRepository_Upsert_Call

+ func (_c *CVERelationshipRepository_Upsert_Call) RunAndReturn(...) *CVERelationshipRepository_Upsert_Call

type ComponentProjectRepository

+ func (_mock *ComponentProjectRepository) FindAllOutdatedProjects() ([]models.ComponentProject, error)

+ func (_mock *ComponentProjectRepository) SaveBatchBestEffort(tx shared.DB, ts []models.ComponentProject) error

type ComponentProjectRepository_Expecter

+ func (_e *ComponentProjectRepository_Expecter) FindAllOutdatedProjects() *ComponentProjectRepository_FindAllOutdatedProjects_Call

+ func (_e *ComponentProjectRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *ComponentProjectRepository_SaveBatchBestEffort_Call

+ type ComponentProjectRepository_FindAllOutdatedProjects_Call struct

+ func (_c *ComponentProjectRepository_FindAllOutdatedProjects_Call) Return(componentProjects []models.ComponentProject, err error) *ComponentProjectRepository_FindAllOutdatedProjects_Call

+ func (_c *ComponentProjectRepository_FindAllOutdatedProjects_Call) Run(run func()) *ComponentProjectRepository_FindAllOutdatedProjects_Call

+ func (_c *ComponentProjectRepository_FindAllOutdatedProjects_Call) RunAndReturn(run func() ([]models.ComponentProject, error)) *ComponentProjectRepository_FindAllOutdatedProjects_Call

+ type ComponentProjectRepository_SaveBatchBestEffort_Call struct

+ func (_c *ComponentProjectRepository_SaveBatchBestEffort_Call) Return(err error) *ComponentProjectRepository_SaveBatchBestEffort_Call

+ func (_c *ComponentProjectRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.ComponentProject)) *ComponentProjectRepository_SaveBatchBestEffort_Call

+ func (_c *ComponentProjectRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.ComponentProject) error) *ComponentProjectRepository_SaveBatchBestEffort_Call

type ComponentRepository

+ func (_mock *ComponentRepository) SaveBatchBestEffort(tx shared.DB, ts []models.Component) error

+ func (_mock *ComponentRepository) SearchComponentOccurrencesByProject(tx shared.DB, projectIDs []uuid.UUID, pageInfo shared.PageInfo, search string) (shared.Paged[models.ComponentOccurrence], error)

type ComponentRepository_Expecter

+ func (_e *ComponentRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *ComponentRepository_SaveBatchBestEffort_Call

+ func (_e *ComponentRepository_Expecter) SearchComponentOccurrencesByProject(tx interface{}, projectIDs interface{}, pageInfo interface{}, ...) *ComponentRepository_SearchComponentOccurrencesByProject_Call

+ type ComponentRepository_SaveBatchBestEffort_Call struct

+ func (_c *ComponentRepository_SaveBatchBestEffort_Call) Return(err error) *ComponentRepository_SaveBatchBestEffort_Call

+ func (_c *ComponentRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.Component)) *ComponentRepository_SaveBatchBestEffort_Call

+ func (_c *ComponentRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.Component) error) *ComponentRepository_SaveBatchBestEffort_Call

+ type ComponentRepository_SearchComponentOccurrencesByProject_Call struct

+ func (_c *ComponentRepository_SearchComponentOccurrencesByProject_Call) Return(paged shared.Paged[models.ComponentOccurrence], err error) *ComponentRepository_SearchComponentOccurrencesByProject_Call

+ func (_c *ComponentRepository_SearchComponentOccurrencesByProject_Call) Run(...) *ComponentRepository_SearchComponentOccurrencesByProject_Call

+ func (_c *ComponentRepository_SearchComponentOccurrencesByProject_Call) RunAndReturn(...) *ComponentRepository_SearchComponentOccurrencesByProject_Call

type CveRepository

+ func (_mock *CveRepository) CreateCVEAffectedComponentsEntries(tx shared.DB, cve *models.CVE, components []models.AffectedComponent) error

+ func (_mock *CveRepository) CreateCVEWithConflictHandling(tx shared.DB, cve *models.CVE) error

+ func (_mock *CveRepository) SaveBatchBestEffort(tx shared.DB, ts []models.CVE) error

+ func (_mock *CveRepository) UpdateCISAKEVBatch(tx shared.DB, batch []models.CVE) error

+ func (_mock *CveRepository) UpdateEpssBatch(tx shared.DB, batch []models.CVE) error

+ type CveRepository_CreateCVEAffectedComponentsEntries_Call struct

+ func (_c *CveRepository_CreateCVEAffectedComponentsEntries_Call) Return(err error) *CveRepository_CreateCVEAffectedComponentsEntries_Call

+ func (_c *CveRepository_CreateCVEAffectedComponentsEntries_Call) Run(run func(tx shared.DB, cve *models.CVE, components []models.AffectedComponent)) *CveRepository_CreateCVEAffectedComponentsEntries_Call

+ func (_c *CveRepository_CreateCVEAffectedComponentsEntries_Call) RunAndReturn(...) *CveRepository_CreateCVEAffectedComponentsEntries_Call

+ type CveRepository_CreateCVEWithConflictHandling_Call struct

+ func (_c *CveRepository_CreateCVEWithConflictHandling_Call) Return(err error) *CveRepository_CreateCVEWithConflictHandling_Call

+ func (_c *CveRepository_CreateCVEWithConflictHandling_Call) Run(run func(tx shared.DB, cve *models.CVE)) *CveRepository_CreateCVEWithConflictHandling_Call

+ func (_c *CveRepository_CreateCVEWithConflictHandling_Call) RunAndReturn(run func(tx shared.DB, cve *models.CVE) error) *CveRepository_CreateCVEWithConflictHandling_Call

type CveRepository_Expecter

+ func (_e *CveRepository_Expecter) CreateCVEAffectedComponentsEntries(tx interface{}, cve interface{}, components interface{}) *CveRepository_CreateCVEAffectedComponentsEntries_Call

+ func (_e *CveRepository_Expecter) CreateCVEWithConflictHandling(tx interface{}, cve interface{}) *CveRepository_CreateCVEWithConflictHandling_Call

+ func (_e *CveRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *CveRepository_SaveBatchBestEffort_Call

+ func (_e *CveRepository_Expecter) UpdateCISAKEVBatch(tx interface{}, batch interface{}) *CveRepository_UpdateCISAKEVBatch_Call

+ func (_e *CveRepository_Expecter) UpdateEpssBatch(tx interface{}, batch interface{}) *CveRepository_UpdateEpssBatch_Call

+ type CveRepository_SaveBatchBestEffort_Call struct

+ func (_c *CveRepository_SaveBatchBestEffort_Call) Return(err error) *CveRepository_SaveBatchBestEffort_Call

+ func (_c *CveRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.CVE)) *CveRepository_SaveBatchBestEffort_Call

+ func (_c *CveRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.CVE) error) *CveRepository_SaveBatchBestEffort_Call

+ type CveRepository_UpdateCISAKEVBatch_Call struct

+ func (_c *CveRepository_UpdateCISAKEVBatch_Call) Return(err error) *CveRepository_UpdateCISAKEVBatch_Call

+ func (_c *CveRepository_UpdateCISAKEVBatch_Call) Run(run func(tx shared.DB, batch []models.CVE)) *CveRepository_UpdateCISAKEVBatch_Call

+ func (_c *CveRepository_UpdateCISAKEVBatch_Call) RunAndReturn(run func(tx shared.DB, batch []models.CVE) error) *CveRepository_UpdateCISAKEVBatch_Call

+ type CveRepository_UpdateEpssBatch_Call struct

+ func (_c *CveRepository_UpdateEpssBatch_Call) Return(err error) *CveRepository_UpdateEpssBatch_Call

+ func (_c *CveRepository_UpdateEpssBatch_Call) Run(run func(tx shared.DB, batch []models.CVE)) *CveRepository_UpdateEpssBatch_Call

+ func (_c *CveRepository_UpdateEpssBatch_Call) RunAndReturn(run func(tx shared.DB, batch []models.CVE) error) *CveRepository_UpdateEpssBatch_Call

+ type DaemonRunner struct

+ func NewDaemonRunner(t interface{ ... }) *DaemonRunner

+ func (_m *DaemonRunner) EXPECT() *DaemonRunner_Expecter

+ func (_mock *DaemonRunner) RunAssetPipeline(forceAll bool)

+ func (_mock *DaemonRunner) RunDaemonPipelineForAsset(assetID uuid.UUID) error

+ func (_mock *DaemonRunner) Start()

+ func (_mock *DaemonRunner) UpdateFixedVersions() error

+ func (_mock *DaemonRunner) UpdateOpenSourceInsightInformation() error

+ func (_mock *DaemonRunner) UpdateVulnDB() error

+ type DaemonRunner_Expecter struct

+ func (_e *DaemonRunner_Expecter) RunAssetPipeline(forceAll interface{}) *DaemonRunner_RunAssetPipeline_Call

+ func (_e *DaemonRunner_Expecter) RunDaemonPipelineForAsset(assetID interface{}) *DaemonRunner_RunDaemonPipelineForAsset_Call

+ func (_e *DaemonRunner_Expecter) Start() *DaemonRunner_Start_Call

+ func (_e *DaemonRunner_Expecter) UpdateFixedVersions() *DaemonRunner_UpdateFixedVersions_Call

+ func (_e *DaemonRunner_Expecter) UpdateOpenSourceInsightInformation() *DaemonRunner_UpdateOpenSourceInsightInformation_Call

+ func (_e *DaemonRunner_Expecter) UpdateVulnDB() *DaemonRunner_UpdateVulnDB_Call

+ type DaemonRunner_RunAssetPipeline_Call struct

+ func (_c *DaemonRunner_RunAssetPipeline_Call) Return() *DaemonRunner_RunAssetPipeline_Call

+ func (_c *DaemonRunner_RunAssetPipeline_Call) Run(run func(forceAll bool)) *DaemonRunner_RunAssetPipeline_Call

+ func (_c *DaemonRunner_RunAssetPipeline_Call) RunAndReturn(run func(forceAll bool)) *DaemonRunner_RunAssetPipeline_Call

+ type DaemonRunner_RunDaemonPipelineForAsset_Call struct

+ func (_c *DaemonRunner_RunDaemonPipelineForAsset_Call) Return(err error) *DaemonRunner_RunDaemonPipelineForAsset_Call

+ func (_c *DaemonRunner_RunDaemonPipelineForAsset_Call) Run(run func(assetID uuid.UUID)) *DaemonRunner_RunDaemonPipelineForAsset_Call

+ func (_c *DaemonRunner_RunDaemonPipelineForAsset_Call) RunAndReturn(run func(assetID uuid.UUID) error) *DaemonRunner_RunDaemonPipelineForAsset_Call

+ type DaemonRunner_Start_Call struct

+ func (_c *DaemonRunner_Start_Call) Return() *DaemonRunner_Start_Call

+ func (_c *DaemonRunner_Start_Call) Run(run func()) *DaemonRunner_Start_Call

+ func (_c *DaemonRunner_Start_Call) RunAndReturn(run func()) *DaemonRunner_Start_Call

+ type DaemonRunner_UpdateFixedVersions_Call struct

+ func (_c *DaemonRunner_UpdateFixedVersions_Call) Return(err error) *DaemonRunner_UpdateFixedVersions_Call

+ func (_c *DaemonRunner_UpdateFixedVersions_Call) Run(run func()) *DaemonRunner_UpdateFixedVersions_Call

+ func (_c *DaemonRunner_UpdateFixedVersions_Call) RunAndReturn(run func() error) *DaemonRunner_UpdateFixedVersions_Call

+ type DaemonRunner_UpdateOpenSourceInsightInformation_Call struct

+ func (_c *DaemonRunner_UpdateOpenSourceInsightInformation_Call) Return(err error) *DaemonRunner_UpdateOpenSourceInsightInformation_Call

+ func (_c *DaemonRunner_UpdateOpenSourceInsightInformation_Call) Run(run func()) *DaemonRunner_UpdateOpenSourceInsightInformation_Call

+ func (_c *DaemonRunner_UpdateOpenSourceInsightInformation_Call) RunAndReturn(run func() error) *DaemonRunner_UpdateOpenSourceInsightInformation_Call

+ type DaemonRunner_UpdateVulnDB_Call struct

+ func (_c *DaemonRunner_UpdateVulnDB_Call) Return(err error) *DaemonRunner_UpdateVulnDB_Call

+ func (_c *DaemonRunner_UpdateVulnDB_Call) Run(run func()) *DaemonRunner_UpdateVulnDB_Call

+ func (_c *DaemonRunner_UpdateVulnDB_Call) RunAndReturn(run func() error) *DaemonRunner_UpdateVulnDB_Call

type DependencyVulnRepository

+ func (_mock *DependencyVulnRepository) FindByCVEAndComponentPurl(tx shared.DB, assetID uuid.UUID, cveID string, componentPurl string) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetAllVulnsByArtifact(tx shared.DB, artifact models.Artifact) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetAllVulnsByAssetIDWithTicketIDs(tx shared.DB, assetID uuid.UUID) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetAllVulnsForTagsAndDefaultBranchInAsset(tx shared.DB, assetID uuid.UUID, excludedStates []dtos.VulnState) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetByAssetID(tx shared.DB, assetID uuid.UUID) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetDependencyVulnByCVEIDAndAssetID(tx shared.DB, cveID string, assetID uuid.UUID) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) SaveBatchBestEffort(tx shared.DB, ts []models.DependencyVuln) error

type DependencyVulnRepository_Expecter

+ func (_e *DependencyVulnRepository_Expecter) FindByCVEAndComponentPurl(tx interface{}, assetID interface{}, cveID interface{}, ...) *DependencyVulnRepository_FindByCVEAndComponentPurl_Call

+ func (_e *DependencyVulnRepository_Expecter) GetAllVulnsByArtifact(tx interface{}, artifact interface{}) *DependencyVulnRepository_GetAllVulnsByArtifact_Call

+ func (_e *DependencyVulnRepository_Expecter) GetAllVulnsByAssetIDWithTicketIDs(tx interface{}, assetID interface{}) *DependencyVulnRepository_GetAllVulnsByAssetIDWithTicketIDs_Call

+ func (_e *DependencyVulnRepository_Expecter) GetAllVulnsForTagsAndDefaultBranchInAsset(tx interface{}, assetID interface{}, excludedStates interface{}) *DependencyVulnRepository_GetAllVulnsForTagsAndDefaultBranchInAsset_Call

+ func (_e *DependencyVulnRepository_Expecter) GetByAssetID(tx interface{}, assetID interface{}) *DependencyVulnRepository_GetByAssetID_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDependencyVulnByCVEIDAndAssetID(tx interface{}, cveID interface{}, assetID interface{}) *DependencyVulnRepository_GetDependencyVulnByCVEIDAndAssetID_Call

+ func (_e *DependencyVulnRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *DependencyVulnRepository_SaveBatchBestEffort_Call

+ type DependencyVulnRepository_FindByCVEAndComponentPurl_Call struct

+ func (_c *DependencyVulnRepository_FindByCVEAndComponentPurl_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_FindByCVEAndComponentPurl_Call

+ func (_c *DependencyVulnRepository_FindByCVEAndComponentPurl_Call) Run(run func(tx shared.DB, assetID uuid.UUID, cveID string, componentPurl string)) *DependencyVulnRepository_FindByCVEAndComponentPurl_Call

+ func (_c *DependencyVulnRepository_FindByCVEAndComponentPurl_Call) RunAndReturn(...) *DependencyVulnRepository_FindByCVEAndComponentPurl_Call

+ type DependencyVulnRepository_GetAllVulnsByArtifact_Call struct

+ func (_c *DependencyVulnRepository_GetAllVulnsByArtifact_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetAllVulnsByArtifact_Call

+ func (_c *DependencyVulnRepository_GetAllVulnsByArtifact_Call) Run(run func(tx shared.DB, artifact models.Artifact)) *DependencyVulnRepository_GetAllVulnsByArtifact_Call

+ func (_c *DependencyVulnRepository_GetAllVulnsByArtifact_Call) RunAndReturn(...) *DependencyVulnRepository_GetAllVulnsByArtifact_Call

+ type DependencyVulnRepository_GetAllVulnsByAssetIDWithTicketIDs_Call struct

+ func (_c *DependencyVulnRepository_GetAllVulnsByAssetIDWithTicketIDs_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetAllVulnsByAssetIDWithTicketIDs_Call

+ func (_c *DependencyVulnRepository_GetAllVulnsByAssetIDWithTicketIDs_Call) Run(run func(tx shared.DB, assetID uuid.UUID)) *DependencyVulnRepository_GetAllVulnsByAssetIDWithTicketIDs_Call

+ func (_c *DependencyVulnRepository_GetAllVulnsByAssetIDWithTicketIDs_Call) RunAndReturn(run func(tx shared.DB, assetID uuid.UUID) ([]models.DependencyVuln, error)) *DependencyVulnRepository_GetAllVulnsByAssetIDWithTicketIDs_Call

+ type DependencyVulnRepository_GetAllVulnsForTagsAndDefaultBranchInAsset_Call struct

+ func (_c *DependencyVulnRepository_GetAllVulnsForTagsAndDefaultBranchInAsset_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetAllVulnsForTagsAndDefaultBranchInAsset_Call

+ func (_c *DependencyVulnRepository_GetAllVulnsForTagsAndDefaultBranchInAsset_Call) Run(run func(tx shared.DB, assetID uuid.UUID, excludedStates []dtos.VulnState)) *DependencyVulnRepository_GetAllVulnsForTagsAndDefaultBranchInAsset_Call

+ func (_c *DependencyVulnRepository_GetAllVulnsForTagsAndDefaultBranchInAsset_Call) RunAndReturn(...) *DependencyVulnRepository_GetAllVulnsForTagsAndDefaultBranchInAsset_Call

+ type DependencyVulnRepository_GetByAssetID_Call struct

+ func (_c *DependencyVulnRepository_GetByAssetID_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetByAssetID_Call

+ func (_c *DependencyVulnRepository_GetByAssetID_Call) Run(run func(tx shared.DB, assetID uuid.UUID)) *DependencyVulnRepository_GetByAssetID_Call

+ func (_c *DependencyVulnRepository_GetByAssetID_Call) RunAndReturn(run func(tx shared.DB, assetID uuid.UUID) ([]models.DependencyVuln, error)) *DependencyVulnRepository_GetByAssetID_Call

+ type DependencyVulnRepository_GetDependencyVulnByCVEIDAndAssetID_Call struct

+ func (_c *DependencyVulnRepository_GetDependencyVulnByCVEIDAndAssetID_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetDependencyVulnByCVEIDAndAssetID_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnByCVEIDAndAssetID_Call) Run(run func(tx shared.DB, cveID string, assetID uuid.UUID)) *DependencyVulnRepository_GetDependencyVulnByCVEIDAndAssetID_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnByCVEIDAndAssetID_Call) RunAndReturn(...) *DependencyVulnRepository_GetDependencyVulnByCVEIDAndAssetID_Call

+ type DependencyVulnRepository_SaveBatchBestEffort_Call struct

+ func (_c *DependencyVulnRepository_SaveBatchBestEffort_Call) Return(err error) *DependencyVulnRepository_SaveBatchBestEffort_Call

+ func (_c *DependencyVulnRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.DependencyVuln)) *DependencyVulnRepository_SaveBatchBestEffort_Call

+ func (_c *DependencyVulnRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.DependencyVuln) error) *DependencyVulnRepository_SaveBatchBestEffort_Call

type ExternalEntityProviderService

+ func (_mock *ExternalEntityProviderService) TriggerSync(c echo.Context) error

type ExternalEntityProviderService_Expecter

+ func (_e *ExternalEntityProviderService_Expecter) TriggerSync(c interface{}) *ExternalEntityProviderService_TriggerSync_Call

+ type ExternalEntityProviderService_TriggerSync_Call struct

+ func (_c *ExternalEntityProviderService_TriggerSync_Call) Return(err error) *ExternalEntityProviderService_TriggerSync_Call

+ func (_c *ExternalEntityProviderService_TriggerSync_Call) Run(run func(c echo.Context)) *ExternalEntityProviderService_TriggerSync_Call

+ func (_c *ExternalEntityProviderService_TriggerSync_Call) RunAndReturn(run func(c echo.Context) error) *ExternalEntityProviderService_TriggerSync_Call

+ type ExternalPropertyFileReference struct

+ func NewExternalPropertyFileReference(t interface{ ... }) *ExternalPropertyFileReference

+ func (_m *ExternalPropertyFileReference) EXPECT() *ExternalPropertyFileReference_Expecter

+ type ExternalPropertyFileReference_Expecter struct

+ type ExternalReferenceRepository struct

+ func NewExternalReferenceRepository(t interface{ ... }) *ExternalReferenceRepository

+ func (_m *ExternalReferenceRepository) EXPECT() *ExternalReferenceRepository_Expecter

+ func (_mock *ExternalReferenceRepository) Activate(tx shared.DB, id uuid.UUID) error

+ func (_mock *ExternalReferenceRepository) All() ([]models.ExternalReference, error)

+ func (_mock *ExternalReferenceRepository) Begin() shared.DB

+ func (_mock *ExternalReferenceRepository) Create(tx shared.DB, t *models.ExternalReference) error

+ func (_mock *ExternalReferenceRepository) CreateBatch(tx shared.DB, ts []models.ExternalReference) error

+ func (_mock *ExternalReferenceRepository) Delete(tx shared.DB, id uuid.UUID) error

+ func (_mock *ExternalReferenceRepository) DeleteBatch(tx shared.DB, ids []models.ExternalReference) error

+ func (_mock *ExternalReferenceRepository) FindByAssetVersion(tx shared.DB, assetID uuid.UUID, assetVersionName string) ([]models.ExternalReference, error)

+ func (_mock *ExternalReferenceRepository) GetDB(tx shared.DB) shared.DB

+ func (_mock *ExternalReferenceRepository) List(ids []uuid.UUID) ([]models.ExternalReference, error)

+ func (_mock *ExternalReferenceRepository) Read(id uuid.UUID) (models.ExternalReference, error)

+ func (_mock *ExternalReferenceRepository) Save(tx shared.DB, t *models.ExternalReference) error

+ func (_mock *ExternalReferenceRepository) SaveBatch(tx shared.DB, ts []models.ExternalReference) error

+ func (_mock *ExternalReferenceRepository) SaveBatchBestEffort(tx shared.DB, ts []models.ExternalReference) error

+ func (_mock *ExternalReferenceRepository) Transaction(fn func(tx shared.DB) error) error

+ func (_mock *ExternalReferenceRepository) Upsert(t *[]*models.ExternalReference, conflictingColumns []clause.Column, ...) error

+ type ExternalReferenceRepository_Activate_Call struct

+ func (_c *ExternalReferenceRepository_Activate_Call) Return(err error) *ExternalReferenceRepository_Activate_Call

+ func (_c *ExternalReferenceRepository_Activate_Call) Run(run func(tx shared.DB, id uuid.UUID)) *ExternalReferenceRepository_Activate_Call

+ func (_c *ExternalReferenceRepository_Activate_Call) RunAndReturn(run func(tx shared.DB, id uuid.UUID) error) *ExternalReferenceRepository_Activate_Call

+ type ExternalReferenceRepository_All_Call struct

+ func (_c *ExternalReferenceRepository_All_Call) Return(externalReferences []models.ExternalReference, err error) *ExternalReferenceRepository_All_Call

+ func (_c *ExternalReferenceRepository_All_Call) Run(run func()) *ExternalReferenceRepository_All_Call

+ func (_c *ExternalReferenceRepository_All_Call) RunAndReturn(run func() ([]models.ExternalReference, error)) *ExternalReferenceRepository_All_Call

+ type ExternalReferenceRepository_Begin_Call struct

+ func (_c *ExternalReferenceRepository_Begin_Call) Return(v shared.DB) *ExternalReferenceRepository_Begin_Call

+ func (_c *ExternalReferenceRepository_Begin_Call) Run(run func()) *ExternalReferenceRepository_Begin_Call

+ func (_c *ExternalReferenceRepository_Begin_Call) RunAndReturn(run func() shared.DB) *ExternalReferenceRepository_Begin_Call

+ type ExternalReferenceRepository_CreateBatch_Call struct

+ func (_c *ExternalReferenceRepository_CreateBatch_Call) Return(err error) *ExternalReferenceRepository_CreateBatch_Call

+ func (_c *ExternalReferenceRepository_CreateBatch_Call) Run(run func(tx shared.DB, ts []models.ExternalReference)) *ExternalReferenceRepository_CreateBatch_Call

+ func (_c *ExternalReferenceRepository_CreateBatch_Call) RunAndReturn(run func(tx shared.DB, ts []models.ExternalReference) error) *ExternalReferenceRepository_CreateBatch_Call

+ type ExternalReferenceRepository_Create_Call struct

+ func (_c *ExternalReferenceRepository_Create_Call) Return(err error) *ExternalReferenceRepository_Create_Call

+ func (_c *ExternalReferenceRepository_Create_Call) Run(run func(tx shared.DB, t *models.ExternalReference)) *ExternalReferenceRepository_Create_Call

+ func (_c *ExternalReferenceRepository_Create_Call) RunAndReturn(run func(tx shared.DB, t *models.ExternalReference) error) *ExternalReferenceRepository_Create_Call

+ type ExternalReferenceRepository_DeleteBatch_Call struct

+ func (_c *ExternalReferenceRepository_DeleteBatch_Call) Return(err error) *ExternalReferenceRepository_DeleteBatch_Call

+ func (_c *ExternalReferenceRepository_DeleteBatch_Call) Run(run func(tx shared.DB, ids []models.ExternalReference)) *ExternalReferenceRepository_DeleteBatch_Call

+ func (_c *ExternalReferenceRepository_DeleteBatch_Call) RunAndReturn(run func(tx shared.DB, ids []models.ExternalReference) error) *ExternalReferenceRepository_DeleteBatch_Call

+ type ExternalReferenceRepository_Delete_Call struct

+ func (_c *ExternalReferenceRepository_Delete_Call) Return(err error) *ExternalReferenceRepository_Delete_Call

+ func (_c *ExternalReferenceRepository_Delete_Call) Run(run func(tx shared.DB, id uuid.UUID)) *ExternalReferenceRepository_Delete_Call

+ func (_c *ExternalReferenceRepository_Delete_Call) RunAndReturn(run func(tx shared.DB, id uuid.UUID) error) *ExternalReferenceRepository_Delete_Call

+ type ExternalReferenceRepository_Expecter struct

+ func (_e *ExternalReferenceRepository_Expecter) Activate(tx interface{}, id interface{}) *ExternalReferenceRepository_Activate_Call

+ func (_e *ExternalReferenceRepository_Expecter) All() *ExternalReferenceRepository_All_Call

+ func (_e *ExternalReferenceRepository_Expecter) Begin() *ExternalReferenceRepository_Begin_Call

+ func (_e *ExternalReferenceRepository_Expecter) Create(tx interface{}, t interface{}) *ExternalReferenceRepository_Create_Call

+ func (_e *ExternalReferenceRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *ExternalReferenceRepository_CreateBatch_Call

+ func (_e *ExternalReferenceRepository_Expecter) Delete(tx interface{}, id interface{}) *ExternalReferenceRepository_Delete_Call

+ func (_e *ExternalReferenceRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *ExternalReferenceRepository_DeleteBatch_Call

+ func (_e *ExternalReferenceRepository_Expecter) FindByAssetVersion(tx interface{}, assetID interface{}, assetVersionName interface{}) *ExternalReferenceRepository_FindByAssetVersion_Call

+ func (_e *ExternalReferenceRepository_Expecter) GetDB(tx interface{}) *ExternalReferenceRepository_GetDB_Call

+ func (_e *ExternalReferenceRepository_Expecter) List(ids interface{}) *ExternalReferenceRepository_List_Call

+ func (_e *ExternalReferenceRepository_Expecter) Read(id interface{}) *ExternalReferenceRepository_Read_Call

+ func (_e *ExternalReferenceRepository_Expecter) Save(tx interface{}, t interface{}) *ExternalReferenceRepository_Save_Call

+ func (_e *ExternalReferenceRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *ExternalReferenceRepository_SaveBatch_Call

+ func (_e *ExternalReferenceRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *ExternalReferenceRepository_SaveBatchBestEffort_Call

+ func (_e *ExternalReferenceRepository_Expecter) Transaction(fn interface{}) *ExternalReferenceRepository_Transaction_Call

+ func (_e *ExternalReferenceRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *ExternalReferenceRepository_Upsert_Call

+ type ExternalReferenceRepository_FindByAssetVersion_Call struct

+ func (_c *ExternalReferenceRepository_FindByAssetVersion_Call) Return(externalReferences []models.ExternalReference, err error) *ExternalReferenceRepository_FindByAssetVersion_Call

+ func (_c *ExternalReferenceRepository_FindByAssetVersion_Call) Run(run func(tx shared.DB, assetID uuid.UUID, assetVersionName string)) *ExternalReferenceRepository_FindByAssetVersion_Call

+ func (_c *ExternalReferenceRepository_FindByAssetVersion_Call) RunAndReturn(...) *ExternalReferenceRepository_FindByAssetVersion_Call

+ type ExternalReferenceRepository_GetDB_Call struct

+ func (_c *ExternalReferenceRepository_GetDB_Call) Return(v shared.DB) *ExternalReferenceRepository_GetDB_Call

+ func (_c *ExternalReferenceRepository_GetDB_Call) Run(run func(tx shared.DB)) *ExternalReferenceRepository_GetDB_Call

+ func (_c *ExternalReferenceRepository_GetDB_Call) RunAndReturn(run func(tx shared.DB) shared.DB) *ExternalReferenceRepository_GetDB_Call

+ type ExternalReferenceRepository_List_Call struct

+ func (_c *ExternalReferenceRepository_List_Call) Return(externalReferences []models.ExternalReference, err error) *ExternalReferenceRepository_List_Call

+ func (_c *ExternalReferenceRepository_List_Call) Run(run func(ids []uuid.UUID)) *ExternalReferenceRepository_List_Call

+ func (_c *ExternalReferenceRepository_List_Call) RunAndReturn(run func(ids []uuid.UUID) ([]models.ExternalReference, error)) *ExternalReferenceRepository_List_Call

+ type ExternalReferenceRepository_Read_Call struct

+ func (_c *ExternalReferenceRepository_Read_Call) Return(externalReference models.ExternalReference, err error) *ExternalReferenceRepository_Read_Call

+ func (_c *ExternalReferenceRepository_Read_Call) Run(run func(id uuid.UUID)) *ExternalReferenceRepository_Read_Call

+ func (_c *ExternalReferenceRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.ExternalReference, error)) *ExternalReferenceRepository_Read_Call

+ type ExternalReferenceRepository_SaveBatchBestEffort_Call struct

+ func (_c *ExternalReferenceRepository_SaveBatchBestEffort_Call) Return(err error) *ExternalReferenceRepository_SaveBatchBestEffort_Call

+ func (_c *ExternalReferenceRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.ExternalReference)) *ExternalReferenceRepository_SaveBatchBestEffort_Call

+ func (_c *ExternalReferenceRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.ExternalReference) error) *ExternalReferenceRepository_SaveBatchBestEffort_Call

+ type ExternalReferenceRepository_SaveBatch_Call struct

+ func (_c *ExternalReferenceRepository_SaveBatch_Call) Return(err error) *ExternalReferenceRepository_SaveBatch_Call

+ func (_c *ExternalReferenceRepository_SaveBatch_Call) Run(run func(tx shared.DB, ts []models.ExternalReference)) *ExternalReferenceRepository_SaveBatch_Call

+ func (_c *ExternalReferenceRepository_SaveBatch_Call) RunAndReturn(run func(tx shared.DB, ts []models.ExternalReference) error) *ExternalReferenceRepository_SaveBatch_Call

+ type ExternalReferenceRepository_Save_Call struct

+ func (_c *ExternalReferenceRepository_Save_Call) Return(err error) *ExternalReferenceRepository_Save_Call

+ func (_c *ExternalReferenceRepository_Save_Call) Run(run func(tx shared.DB, t *models.ExternalReference)) *ExternalReferenceRepository_Save_Call

+ func (_c *ExternalReferenceRepository_Save_Call) RunAndReturn(run func(tx shared.DB, t *models.ExternalReference) error) *ExternalReferenceRepository_Save_Call

+ type ExternalReferenceRepository_Transaction_Call struct

+ func (_c *ExternalReferenceRepository_Transaction_Call) Return(err error) *ExternalReferenceRepository_Transaction_Call

+ func (_c *ExternalReferenceRepository_Transaction_Call) Run(run func(fn func(tx shared.DB) error)) *ExternalReferenceRepository_Transaction_Call

+ func (_c *ExternalReferenceRepository_Transaction_Call) RunAndReturn(run func(fn func(tx shared.DB) error) error) *ExternalReferenceRepository_Transaction_Call

+ type ExternalReferenceRepository_Upsert_Call struct

+ func (_c *ExternalReferenceRepository_Upsert_Call) Return(err error) *ExternalReferenceRepository_Upsert_Call

+ func (_c *ExternalReferenceRepository_Upsert_Call) Run(...) *ExternalReferenceRepository_Upsert_Call

+ func (_c *ExternalReferenceRepository_Upsert_Call) RunAndReturn(...) *ExternalReferenceRepository_Upsert_Call

type FirstPartyVulnRepository

+ func (_mock *FirstPartyVulnRepository) ListUnfixedByAssetAndAssetVersionAndScanner(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.FirstPartyVuln, error)

+ func (_mock *FirstPartyVulnRepository) SaveBatchBestEffort(tx shared.DB, ts []models.FirstPartyVuln) error

type FirstPartyVulnRepository_Expecter

+ func (_e *FirstPartyVulnRepository_Expecter) ListUnfixedByAssetAndAssetVersionAndScanner(assetVersionName interface{}, assetID interface{}, scannerID interface{}) *FirstPartyVulnRepository_ListUnfixedByAssetAndAssetVersionAndScanner_Call

+ func (_e *FirstPartyVulnRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *FirstPartyVulnRepository_SaveBatchBestEffort_Call

+ type FirstPartyVulnRepository_ListUnfixedByAssetAndAssetVersionAndScanner_Call struct

+ func (_c *FirstPartyVulnRepository_ListUnfixedByAssetAndAssetVersionAndScanner_Call) Return(firstPartyVulns []models.FirstPartyVuln, err error) *FirstPartyVulnRepository_ListUnfixedByAssetAndAssetVersionAndScanner_Call

+ func (_c *FirstPartyVulnRepository_ListUnfixedByAssetAndAssetVersionAndScanner_Call) Run(run func(assetVersionName string, assetID uuid.UUID, scannerID string)) *FirstPartyVulnRepository_ListUnfixedByAssetAndAssetVersionAndScanner_Call

+ func (_c *FirstPartyVulnRepository_ListUnfixedByAssetAndAssetVersionAndScanner_Call) RunAndReturn(...) *FirstPartyVulnRepository_ListUnfixedByAssetAndAssetVersionAndScanner_Call

+ type FirstPartyVulnRepository_SaveBatchBestEffort_Call struct

+ func (_c *FirstPartyVulnRepository_SaveBatchBestEffort_Call) Return(err error) *FirstPartyVulnRepository_SaveBatchBestEffort_Call

+ func (_c *FirstPartyVulnRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.FirstPartyVuln)) *FirstPartyVulnRepository_SaveBatchBestEffort_Call

+ func (_c *FirstPartyVulnRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.FirstPartyVuln) error) *FirstPartyVulnRepository_SaveBatchBestEffort_Call

+ type GraphComponent struct

+ func NewGraphComponent(t interface{ ... }) *GraphComponent

+ func (_m *GraphComponent) EXPECT() *GraphComponent_Expecter

+ func (_mock *GraphComponent) GetDependentID() *string

+ func (_mock *GraphComponent) GetID() string

+ func (_mock *GraphComponent) ToCdxComponent(componentLicenseOverwrites map[string]string) (cyclonedx.Component, error)

+ type GraphComponent_Expecter struct

+ func (_e *GraphComponent_Expecter) GetDependentID() *GraphComponent_GetDependentID_Call

+ func (_e *GraphComponent_Expecter) GetID() *GraphComponent_GetID_Call

+ func (_e *GraphComponent_Expecter) ToCdxComponent(componentLicenseOverwrites interface{}) *GraphComponent_ToCdxComponent_Call

+ type GraphComponent_GetDependentID_Call struct

+ func (_c *GraphComponent_GetDependentID_Call) Return(s *string) *GraphComponent_GetDependentID_Call

+ func (_c *GraphComponent_GetDependentID_Call) Run(run func()) *GraphComponent_GetDependentID_Call

+ func (_c *GraphComponent_GetDependentID_Call) RunAndReturn(run func() *string) *GraphComponent_GetDependentID_Call

+ type GraphComponent_GetID_Call struct

+ func (_c *GraphComponent_GetID_Call) Return(s string) *GraphComponent_GetID_Call

+ func (_c *GraphComponent_GetID_Call) Run(run func()) *GraphComponent_GetID_Call

+ func (_c *GraphComponent_GetID_Call) RunAndReturn(run func() string) *GraphComponent_GetID_Call

+ type GraphComponent_ToCdxComponent_Call struct

+ func (_c *GraphComponent_ToCdxComponent_Call) Return(component cyclonedx.Component, err error) *GraphComponent_ToCdxComponent_Call

+ func (_c *GraphComponent_ToCdxComponent_Call) Run(run func(componentLicenseOverwrites map[string]string)) *GraphComponent_ToCdxComponent_Call

+ func (_c *GraphComponent_ToCdxComponent_Call) RunAndReturn(...) *GraphComponent_ToCdxComponent_Call

type InTotoLinkRepository

+ func (_mock *InTotoLinkRepository) SaveBatchBestEffort(tx shared.DB, ts []models.InTotoLink) error

type InTotoLinkRepository_Expecter

+ func (_e *InTotoLinkRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *InTotoLinkRepository_SaveBatchBestEffort_Call

+ type InTotoLinkRepository_SaveBatchBestEffort_Call struct

+ func (_c *InTotoLinkRepository_SaveBatchBestEffort_Call) Return(err error) *InTotoLinkRepository_SaveBatchBestEffort_Call

+ func (_c *InTotoLinkRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.InTotoLink)) *InTotoLinkRepository_SaveBatchBestEffort_Call

+ func (_c *InTotoLinkRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.InTotoLink) error) *InTotoLinkRepository_SaveBatchBestEffort_Call

type InTotoVerifierService

+ func (_mock *InTotoVerifierService) HexPublicKeyToInTotoKey(hexPubKey string) (in_toto.Key, error)

type InTotoVerifierService_Expecter

+ func (_e *InTotoVerifierService_Expecter) HexPublicKeyToInTotoKey(hexPubKey interface{}) *InTotoVerifierService_HexPublicKeyToInTotoKey_Call

+ type InTotoVerifierService_HexPublicKeyToInTotoKey_Call struct

+ func (_c *InTotoVerifierService_HexPublicKeyToInTotoKey_Call) Return(key in_toto.Key, err error) *InTotoVerifierService_HexPublicKeyToInTotoKey_Call

+ func (_c *InTotoVerifierService_HexPublicKeyToInTotoKey_Call) Run(run func(hexPubKey string)) *InTotoVerifierService_HexPublicKeyToInTotoKey_Call

+ func (_c *InTotoVerifierService_HexPublicKeyToInTotoKey_Call) RunAndReturn(run func(hexPubKey string) (in_toto.Key, error)) *InTotoVerifierService_HexPublicKeyToInTotoKey_Call

type IntegrationAggregate

+ func (_mock *IntegrationAggregate) CompareIssueStatesAndResolveDifferences(asset models.Asset, vulnsWithTickets []models.DependencyVuln) error

+ type IntegrationAggregate_CompareIssueStatesAndResolveDifferences_Call struct

+ func (_c *IntegrationAggregate_CompareIssueStatesAndResolveDifferences_Call) Return(err error) *IntegrationAggregate_CompareIssueStatesAndResolveDifferences_Call

+ func (_c *IntegrationAggregate_CompareIssueStatesAndResolveDifferences_Call) Run(run func(asset models.Asset, vulnsWithTickets []models.DependencyVuln)) *IntegrationAggregate_CompareIssueStatesAndResolveDifferences_Call

+ func (_c *IntegrationAggregate_CompareIssueStatesAndResolveDifferences_Call) RunAndReturn(run func(asset models.Asset, vulnsWithTickets []models.DependencyVuln) error) *IntegrationAggregate_CompareIssueStatesAndResolveDifferences_Call

type IntegrationAggregate_Expecter

+ func (_e *IntegrationAggregate_Expecter) CompareIssueStatesAndResolveDifferences(asset interface{}, vulnsWithTickets interface{}) *IntegrationAggregate_CompareIssueStatesAndResolveDifferences_Call

+ type LeaderElector struct

+ func NewLeaderElector(t interface{ ... }) *LeaderElector

+ func (_m *LeaderElector) EXPECT() *LeaderElector_Expecter

+ func (_mock *LeaderElector) IsLeader() bool

+ type LeaderElector_Expecter struct

+ func (_e *LeaderElector_Expecter) IsLeader() *LeaderElector_IsLeader_Call

+ type LeaderElector_IsLeader_Call struct

+ func (_c *LeaderElector_IsLeader_Call) Return(b bool) *LeaderElector_IsLeader_Call

+ func (_c *LeaderElector_IsLeader_Call) Run(run func()) *LeaderElector_IsLeader_Call

+ func (_c *LeaderElector_IsLeader_Call) RunAndReturn(run func() bool) *LeaderElector_IsLeader_Call

type LicenseRiskRepository

+ func (_mock *LicenseRiskRepository) GetByAssetID(tx shared.DB, assetID uuid.UUID) ([]models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) SaveBatchBestEffort(tx shared.DB, ts []models.LicenseRisk) error

type LicenseRiskRepository_Expecter

+ func (_e *LicenseRiskRepository_Expecter) GetByAssetID(tx interface{}, assetID interface{}) *LicenseRiskRepository_GetByAssetID_Call

+ func (_e *LicenseRiskRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *LicenseRiskRepository_SaveBatchBestEffort_Call

+ type LicenseRiskRepository_GetByAssetID_Call struct

+ func (_c *LicenseRiskRepository_GetByAssetID_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_GetByAssetID_Call

+ func (_c *LicenseRiskRepository_GetByAssetID_Call) Run(run func(tx shared.DB, assetID uuid.UUID)) *LicenseRiskRepository_GetByAssetID_Call

+ func (_c *LicenseRiskRepository_GetByAssetID_Call) RunAndReturn(run func(tx shared.DB, assetID uuid.UUID) ([]models.LicenseRisk, error)) *LicenseRiskRepository_GetByAssetID_Call

+ type LicenseRiskRepository_SaveBatchBestEffort_Call struct

+ func (_c *LicenseRiskRepository_SaveBatchBestEffort_Call) Return(err error) *LicenseRiskRepository_SaveBatchBestEffort_Call

+ func (_c *LicenseRiskRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.LicenseRisk)) *LicenseRiskRepository_SaveBatchBestEffort_Call

+ func (_c *LicenseRiskRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.LicenseRisk) error) *LicenseRiskRepository_SaveBatchBestEffort_Call

+ type MaliciousPackageChecker struct

+ func NewMaliciousPackageChecker(t interface{ ... }) *MaliciousPackageChecker

+ func (_m *MaliciousPackageChecker) EXPECT() *MaliciousPackageChecker_Expecter

+ func (_mock *MaliciousPackageChecker) DownloadAndProcessDB() error

+ func (_mock *MaliciousPackageChecker) IsMalicious(ecosystem string, packageName string, version string) (bool, *dtos.OSV)

+ type MaliciousPackageChecker_DownloadAndProcessDB_Call struct

+ func (_c *MaliciousPackageChecker_DownloadAndProcessDB_Call) Return(err error) *MaliciousPackageChecker_DownloadAndProcessDB_Call

+ func (_c *MaliciousPackageChecker_DownloadAndProcessDB_Call) Run(run func()) *MaliciousPackageChecker_DownloadAndProcessDB_Call

+ func (_c *MaliciousPackageChecker_DownloadAndProcessDB_Call) RunAndReturn(run func() error) *MaliciousPackageChecker_DownloadAndProcessDB_Call

+ type MaliciousPackageChecker_Expecter struct

+ func (_e *MaliciousPackageChecker_Expecter) DownloadAndProcessDB() *MaliciousPackageChecker_DownloadAndProcessDB_Call

+ func (_e *MaliciousPackageChecker_Expecter) IsMalicious(ecosystem interface{}, packageName interface{}, version interface{}) *MaliciousPackageChecker_IsMalicious_Call

+ type MaliciousPackageChecker_IsMalicious_Call struct

+ func (_c *MaliciousPackageChecker_IsMalicious_Call) Return(b bool, oSV *dtos.OSV) *MaliciousPackageChecker_IsMalicious_Call

+ func (_c *MaliciousPackageChecker_IsMalicious_Call) Run(run func(ecosystem string, packageName string, version string)) *MaliciousPackageChecker_IsMalicious_Call

+ func (_c *MaliciousPackageChecker_IsMalicious_Call) RunAndReturn(...) *MaliciousPackageChecker_IsMalicious_Call

+ type ModelReader struct

+ func NewModelReader[ID any, T utils.Tabler](t interface{ ... }) *ModelReader[ID, T]

+ func (_m *ModelReader[ID, T]) EXPECT() *ModelReader_Expecter[ID, T]

+ func (_mock *ModelReader[ID, T]) All() ([]T, error)

+ func (_mock *ModelReader[ID, T]) List(ids []ID) ([]T, error)

+ func (_mock *ModelReader[ID, T]) Read(id ID) (T, error)

+ func (_mock *ModelReader[ID, T]) Upsert(t *[]*T, conflictingColumns []clause.Column, updateOnly []string) error

+ type ModelReader_All_Call struct

+ func (_c *ModelReader_All_Call[ID, T]) Return(vs []T, err error) *ModelReader_All_Call[ID, T]

+ func (_c *ModelReader_All_Call[ID, T]) Run(run func()) *ModelReader_All_Call[ID, T]

+ func (_c *ModelReader_All_Call[ID, T]) RunAndReturn(run func() ([]T, error)) *ModelReader_All_Call[ID, T]

+ type ModelReader_Expecter struct

+ func (_e *ModelReader_Expecter[ID, T]) All() *ModelReader_All_Call[ID, T]

+ func (_e *ModelReader_Expecter[ID, T]) List(ids interface{}) *ModelReader_List_Call[ID, T]

+ func (_e *ModelReader_Expecter[ID, T]) Read(id interface{}) *ModelReader_Read_Call[ID, T]

+ func (_e *ModelReader_Expecter[ID, T]) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *ModelReader_Upsert_Call[ID, T]

+ type ModelReader_List_Call struct

+ func (_c *ModelReader_List_Call[ID, T]) Return(vs []T, err error) *ModelReader_List_Call[ID, T]

+ func (_c *ModelReader_List_Call[ID, T]) Run(run func(ids []ID)) *ModelReader_List_Call[ID, T]

+ func (_c *ModelReader_List_Call[ID, T]) RunAndReturn(run func(ids []ID) ([]T, error)) *ModelReader_List_Call[ID, T]

+ type ModelReader_Read_Call struct

+ func (_c *ModelReader_Read_Call[ID, T]) Return(v T, err error) *ModelReader_Read_Call[ID, T]

+ func (_c *ModelReader_Read_Call[ID, T]) Run(run func(id ID)) *ModelReader_Read_Call[ID, T]

+ func (_c *ModelReader_Read_Call[ID, T]) RunAndReturn(run func(id ID) (T, error)) *ModelReader_Read_Call[ID, T]

+ type ModelReader_Upsert_Call struct

+ func (_c *ModelReader_Upsert_Call[ID, T]) Return(err error) *ModelReader_Upsert_Call[ID, T]

+ func (_c *ModelReader_Upsert_Call[ID, T]) Run(run func(t *[]*T, conflictingColumns []clause.Column, updateOnly []string)) *ModelReader_Upsert_Call[ID, T]

+ func (_c *ModelReader_Upsert_Call[ID, T]) RunAndReturn(...) *ModelReader_Upsert_Call[ID, T]

+ type ModelWriter struct

+ func NewModelWriter[ID any, T utils.Tabler, Tx any](t interface{ ... }) *ModelWriter[ID, T, Tx]

+ func (_m *ModelWriter[ID, T, Tx]) EXPECT() *ModelWriter_Expecter[ID, T, Tx]

+ func (_mock *ModelWriter[ID, T, Tx]) Activate(tx Tx, id ID) error

+ func (_mock *ModelWriter[ID, T, Tx]) Create(tx Tx, t *T) error

+ func (_mock *ModelWriter[ID, T, Tx]) Delete(tx Tx, id ID) error

+ func (_mock *ModelWriter[ID, T, Tx]) Save(tx Tx, t *T) error

+ type ModelWriter_Activate_Call struct

+ func (_c *ModelWriter_Activate_Call[ID, T, Tx]) Return(err error) *ModelWriter_Activate_Call[ID, T, Tx]

+ func (_c *ModelWriter_Activate_Call[ID, T, Tx]) Run(run func(tx Tx, id ID)) *ModelWriter_Activate_Call[ID, T, Tx]

+ func (_c *ModelWriter_Activate_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, id ID) error) *ModelWriter_Activate_Call[ID, T, Tx]

+ type ModelWriter_Create_Call struct

+ func (_c *ModelWriter_Create_Call[ID, T, Tx]) Return(err error) *ModelWriter_Create_Call[ID, T, Tx]

+ func (_c *ModelWriter_Create_Call[ID, T, Tx]) Run(run func(tx Tx, t *T)) *ModelWriter_Create_Call[ID, T, Tx]

+ func (_c *ModelWriter_Create_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, t *T) error) *ModelWriter_Create_Call[ID, T, Tx]

+ type ModelWriter_Delete_Call struct

+ func (_c *ModelWriter_Delete_Call[ID, T, Tx]) Return(err error) *ModelWriter_Delete_Call[ID, T, Tx]

+ func (_c *ModelWriter_Delete_Call[ID, T, Tx]) Run(run func(tx Tx, id ID)) *ModelWriter_Delete_Call[ID, T, Tx]

+ func (_c *ModelWriter_Delete_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, id ID) error) *ModelWriter_Delete_Call[ID, T, Tx]

+ type ModelWriter_Expecter struct

+ func (_e *ModelWriter_Expecter[ID, T, Tx]) Activate(tx interface{}, id interface{}) *ModelWriter_Activate_Call[ID, T, Tx]

+ func (_e *ModelWriter_Expecter[ID, T, Tx]) Create(tx interface{}, t interface{}) *ModelWriter_Create_Call[ID, T, Tx]

+ func (_e *ModelWriter_Expecter[ID, T, Tx]) Delete(tx interface{}, id interface{}) *ModelWriter_Delete_Call[ID, T, Tx]

+ func (_e *ModelWriter_Expecter[ID, T, Tx]) Save(tx interface{}, t interface{}) *ModelWriter_Save_Call[ID, T, Tx]

+ type ModelWriter_Save_Call struct

+ func (_c *ModelWriter_Save_Call[ID, T, Tx]) Return(err error) *ModelWriter_Save_Call[ID, T, Tx]

+ func (_c *ModelWriter_Save_Call[ID, T, Tx]) Run(run func(tx Tx, t *T)) *ModelWriter_Save_Call[ID, T, Tx]

+ func (_c *ModelWriter_Save_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, t *T) error) *ModelWriter_Save_Call[ID, T, Tx]

type OrganizationRepository

+ func (_mock *OrganizationRepository) GetOrgsWithVulnSharingAssets() ([]models.Org, error)

+ func (_mock *OrganizationRepository) SaveBatchBestEffort(tx shared.DB, ts []models.Org) error

type OrganizationRepository_Expecter

+ func (_e *OrganizationRepository_Expecter) GetOrgsWithVulnSharingAssets() *OrganizationRepository_GetOrgsWithVulnSharingAssets_Call

+ func (_e *OrganizationRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *OrganizationRepository_SaveBatchBestEffort_Call

+ type OrganizationRepository_GetOrgsWithVulnSharingAssets_Call struct

+ func (_c *OrganizationRepository_GetOrgsWithVulnSharingAssets_Call) Return(orgs []models.Org, err error) *OrganizationRepository_GetOrgsWithVulnSharingAssets_Call

+ func (_c *OrganizationRepository_GetOrgsWithVulnSharingAssets_Call) Run(run func()) *OrganizationRepository_GetOrgsWithVulnSharingAssets_Call

+ func (_c *OrganizationRepository_GetOrgsWithVulnSharingAssets_Call) RunAndReturn(run func() ([]models.Org, error)) *OrganizationRepository_GetOrgsWithVulnSharingAssets_Call

+ type OrganizationRepository_SaveBatchBestEffort_Call struct

+ func (_c *OrganizationRepository_SaveBatchBestEffort_Call) Return(err error) *OrganizationRepository_SaveBatchBestEffort_Call

+ func (_c *OrganizationRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.Org)) *OrganizationRepository_SaveBatchBestEffort_Call

+ func (_c *OrganizationRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.Org) error) *OrganizationRepository_SaveBatchBestEffort_Call

type PersonalAccessTokenRepository

+ func (_mock *PersonalAccessTokenRepository) SaveBatchBestEffort(tx shared.DB, ts []models.PAT) error

type PersonalAccessTokenRepository_Expecter

+ func (_e *PersonalAccessTokenRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *PersonalAccessTokenRepository_SaveBatchBestEffort_Call

+ type PersonalAccessTokenRepository_SaveBatchBestEffort_Call struct

+ func (_c *PersonalAccessTokenRepository_SaveBatchBestEffort_Call) Return(err error) *PersonalAccessTokenRepository_SaveBatchBestEffort_Call

+ func (_c *PersonalAccessTokenRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.PAT)) *PersonalAccessTokenRepository_SaveBatchBestEffort_Call

+ func (_c *PersonalAccessTokenRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.PAT) error) *PersonalAccessTokenRepository_SaveBatchBestEffort_Call

+ type PersonalAccessTokenService struct

+ func NewPersonalAccessTokenService(t interface{ ... }) *PersonalAccessTokenService

+ func (_m *PersonalAccessTokenService) EXPECT() *PersonalAccessTokenService_Expecter

+ func (_mock *PersonalAccessTokenService) RevokeByPrivateKey(privKey string) error

+ func (_mock *PersonalAccessTokenService) ToModel(request dtos.PatCreateRequest, userID string) models.PAT

+ func (_mock *PersonalAccessTokenService) VerifyRequestSignature(req *http.Request) (string, string, error)

+ type PersonalAccessTokenService_Expecter struct

+ func (_e *PersonalAccessTokenService_Expecter) RevokeByPrivateKey(privKey interface{}) *PersonalAccessTokenService_RevokeByPrivateKey_Call

+ func (_e *PersonalAccessTokenService_Expecter) ToModel(request interface{}, userID interface{}) *PersonalAccessTokenService_ToModel_Call

+ func (_e *PersonalAccessTokenService_Expecter) VerifyRequestSignature(req interface{}) *PersonalAccessTokenService_VerifyRequestSignature_Call

+ type PersonalAccessTokenService_RevokeByPrivateKey_Call struct

+ func (_c *PersonalAccessTokenService_RevokeByPrivateKey_Call) Return(err error) *PersonalAccessTokenService_RevokeByPrivateKey_Call

+ func (_c *PersonalAccessTokenService_RevokeByPrivateKey_Call) Run(run func(privKey string)) *PersonalAccessTokenService_RevokeByPrivateKey_Call

+ func (_c *PersonalAccessTokenService_RevokeByPrivateKey_Call) RunAndReturn(run func(privKey string) error) *PersonalAccessTokenService_RevokeByPrivateKey_Call

+ type PersonalAccessTokenService_ToModel_Call struct

+ func (_c *PersonalAccessTokenService_ToModel_Call) Return(pAT models.PAT) *PersonalAccessTokenService_ToModel_Call

+ func (_c *PersonalAccessTokenService_ToModel_Call) Run(run func(request dtos.PatCreateRequest, userID string)) *PersonalAccessTokenService_ToModel_Call

+ func (_c *PersonalAccessTokenService_ToModel_Call) RunAndReturn(run func(request dtos.PatCreateRequest, userID string) models.PAT) *PersonalAccessTokenService_ToModel_Call

+ type PersonalAccessTokenService_VerifyRequestSignature_Call struct

+ func (_c *PersonalAccessTokenService_VerifyRequestSignature_Call) Return(s string, s1 string, err error) *PersonalAccessTokenService_VerifyRequestSignature_Call

+ func (_c *PersonalAccessTokenService_VerifyRequestSignature_Call) Run(run func(req *http.Request)) *PersonalAccessTokenService_VerifyRequestSignature_Call

+ func (_c *PersonalAccessTokenService_VerifyRequestSignature_Call) RunAndReturn(run func(req *http.Request) (string, string, error)) *PersonalAccessTokenService_VerifyRequestSignature_Call

type PolicyRepository

+ func (_mock *PolicyRepository) SaveBatchBestEffort(tx shared.DB, ts []models.Policy) error

type PolicyRepository_Expecter

+ func (_e *PolicyRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *PolicyRepository_SaveBatchBestEffort_Call

+ type PolicyRepository_SaveBatchBestEffort_Call struct

+ func (_c *PolicyRepository_SaveBatchBestEffort_Call) Return(err error) *PolicyRepository_SaveBatchBestEffort_Call

+ func (_c *PolicyRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.Policy)) *PolicyRepository_SaveBatchBestEffort_Call

+ func (_c *PolicyRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.Policy) error) *PolicyRepository_SaveBatchBestEffort_Call

type ProjectRepository

+ func (_mock *ProjectRepository) ListSubProjectsAndAssets(allowedAssetIDs []string, allowedProjectIDs []uuid.UUID, parentID *uuid.UUID, ...) (shared.Paged[dtos.ProjectAssetDTO], error)

type ProjectRepository_Expecter

+ func (_e *ProjectRepository_Expecter) ListSubProjectsAndAssets(allowedAssetIDs interface{}, allowedProjectIDs interface{}, ...) *ProjectRepository_ListSubProjectsAndAssets_Call

+ type ProjectRepository_ListSubProjectsAndAssets_Call struct

+ func (_c *ProjectRepository_ListSubProjectsAndAssets_Call) Return(paged shared.Paged[dtos.ProjectAssetDTO], err error) *ProjectRepository_ListSubProjectsAndAssets_Call

+ func (_c *ProjectRepository_ListSubProjectsAndAssets_Call) Run(...) *ProjectRepository_ListSubProjectsAndAssets_Call

+ func (_c *ProjectRepository_ListSubProjectsAndAssets_Call) RunAndReturn(...) *ProjectRepository_ListSubProjectsAndAssets_Call

type ProjectService

+ func (_mock *ProjectService) ListAllowedSubProjectsAndAssetsPaged(c shared.Context) (shared.Paged[dtos.ProjectAssetDTO], error)

type ProjectService_Expecter

+ func (_e *ProjectService_Expecter) ListAllowedSubProjectsAndAssetsPaged(c interface{}) *ProjectService_ListAllowedSubProjectsAndAssetsPaged_Call

+ type ProjectService_ListAllowedSubProjectsAndAssetsPaged_Call struct

+ func (_c *ProjectService_ListAllowedSubProjectsAndAssetsPaged_Call) Return(paged shared.Paged[dtos.ProjectAssetDTO], err error) *ProjectService_ListAllowedSubProjectsAndAssetsPaged_Call

+ func (_c *ProjectService_ListAllowedSubProjectsAndAssetsPaged_Call) Run(run func(c shared.Context)) *ProjectService_ListAllowedSubProjectsAndAssetsPaged_Call

+ func (_c *ProjectService_ListAllowedSubProjectsAndAssetsPaged_Call) RunAndReturn(run func(c shared.Context) (shared.Paged[dtos.ProjectAssetDTO], error)) *ProjectService_ListAllowedSubProjectsAndAssetsPaged_Call

+ type PubSubBroker struct

+ func NewPubSubBroker(t interface{ ... }) *PubSubBroker

+ func (_m *PubSubBroker) EXPECT() *PubSubBroker_Expecter

+ func (_mock *PubSubBroker) Publish(ctx context.Context, message shared.PubSubMessage) error

+ func (_mock *PubSubBroker) Subscribe(topic shared.PubSubChannel) (<-chan map[string]any, error)

+ type PubSubBroker_Expecter struct

+ func (_e *PubSubBroker_Expecter) Publish(ctx interface{}, message interface{}) *PubSubBroker_Publish_Call

+ func (_e *PubSubBroker_Expecter) Subscribe(topic interface{}) *PubSubBroker_Subscribe_Call

+ type PubSubBroker_Publish_Call struct

+ func (_c *PubSubBroker_Publish_Call) Return(err error) *PubSubBroker_Publish_Call

+ func (_c *PubSubBroker_Publish_Call) Run(run func(ctx context.Context, message shared.PubSubMessage)) *PubSubBroker_Publish_Call

+ func (_c *PubSubBroker_Publish_Call) RunAndReturn(run func(ctx context.Context, message shared.PubSubMessage) error) *PubSubBroker_Publish_Call

+ type PubSubBroker_Subscribe_Call struct

+ func (_c *PubSubBroker_Subscribe_Call) Return(stringToVCh <-chan map[string]any, err error) *PubSubBroker_Subscribe_Call

+ func (_c *PubSubBroker_Subscribe_Call) Run(run func(topic shared.PubSubChannel)) *PubSubBroker_Subscribe_Call

+ func (_c *PubSubBroker_Subscribe_Call) RunAndReturn(run func(topic shared.PubSubChannel) (<-chan map[string]any, error)) *PubSubBroker_Subscribe_Call

+ type PubSubMessage struct

+ func NewPubSubMessage(t interface{ ... }) *PubSubMessage

+ func (_m *PubSubMessage) EXPECT() *PubSubMessage_Expecter

+ func (_mock *PubSubMessage) GetChannel() shared.PubSubChannel

+ func (_mock *PubSubMessage) GetPayload() map[string]any

+ type PubSubMessage_Expecter struct

+ func (_e *PubSubMessage_Expecter) GetChannel() *PubSubMessage_GetChannel_Call

+ func (_e *PubSubMessage_Expecter) GetPayload() *PubSubMessage_GetPayload_Call

+ type PubSubMessage_GetChannel_Call struct

+ func (_c *PubSubMessage_GetChannel_Call) Return(pubSubChannel shared.PubSubChannel) *PubSubMessage_GetChannel_Call

+ func (_c *PubSubMessage_GetChannel_Call) Run(run func()) *PubSubMessage_GetChannel_Call

+ func (_c *PubSubMessage_GetChannel_Call) RunAndReturn(run func() shared.PubSubChannel) *PubSubMessage_GetChannel_Call

+ type PubSubMessage_GetPayload_Call struct

+ func (_c *PubSubMessage_GetPayload_Call) Return(stringToV map[string]any) *PubSubMessage_GetPayload_Call

+ func (_c *PubSubMessage_GetPayload_Call) Run(run func()) *PubSubMessage_GetPayload_Call

+ func (_c *PubSubMessage_GetPayload_Call) RunAndReturn(run func() map[string]any) *PubSubMessage_GetPayload_Call

+ type PublicClient struct

+ func NewPublicClient(t interface{ ... }) *PublicClient

+ func (_m *PublicClient) EXPECT() *PublicClient_Expecter

+ func (_mock *PublicClient) GetIdentityFromCookie(ctx context.Context, cookie string) (client.Identity, error)

+ type PublicClient_Expecter struct

+ func (_e *PublicClient_Expecter) GetIdentityFromCookie(ctx interface{}, cookie interface{}) *PublicClient_GetIdentityFromCookie_Call

+ type PublicClient_GetIdentityFromCookie_Call struct

+ func (_c *PublicClient_GetIdentityFromCookie_Call) Return(identity client.Identity, err error) *PublicClient_GetIdentityFromCookie_Call

+ func (_c *PublicClient_GetIdentityFromCookie_Call) Run(run func(ctx context.Context, cookie string)) *PublicClient_GetIdentityFromCookie_Call

+ func (_c *PublicClient_GetIdentityFromCookie_Call) RunAndReturn(run func(ctx context.Context, cookie string) (client.Identity, error)) *PublicClient_GetIdentityFromCookie_Call

type ReleaseRepository

+ func (_mock *ReleaseRepository) SaveBatchBestEffort(tx shared.DB, ts []models.Release) error

type ReleaseRepository_Expecter

+ func (_e *ReleaseRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *ReleaseRepository_SaveBatchBestEffort_Call

+ type ReleaseRepository_SaveBatchBestEffort_Call struct

+ func (_c *ReleaseRepository_SaveBatchBestEffort_Call) Return(err error) *ReleaseRepository_SaveBatchBestEffort_Call

+ func (_c *ReleaseRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.Release)) *ReleaseRepository_SaveBatchBestEffort_Call

+ func (_c *ReleaseRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.Release) error) *ReleaseRepository_SaveBatchBestEffort_Call

+ type ReleaseService struct

+ func NewReleaseService(t interface{ ... }) *ReleaseService

+ func (_m *ReleaseService) EXPECT() *ReleaseService_Expecter

+ func (_mock *ReleaseService) AddItem(item *models.ReleaseItem) error

+ func (_mock *ReleaseService) Create(r *models.Release) error

+ func (_mock *ReleaseService) Delete(id uuid.UUID) error

+ func (_mock *ReleaseService) ListByProject(projectID uuid.UUID) ([]models.Release, error)

+ func (_mock *ReleaseService) ListByProjectPaged(projectID uuid.UUID, pageInfo shared.PageInfo, search string, ...) (shared.Paged[models.Release], error)

+ func (_mock *ReleaseService) ListCandidates(projectID uuid.UUID, releaseID *uuid.UUID) ([]models.Artifact, []models.Release, error)

+ func (_mock *ReleaseService) Read(id uuid.UUID) (models.Release, error)

+ func (_mock *ReleaseService) ReadRecursive(id uuid.UUID) (models.Release, error)

+ func (_mock *ReleaseService) RemoveItem(id uuid.UUID) error

+ func (_mock *ReleaseService) Update(r *models.Release) error

+ type ReleaseService_AddItem_Call struct

+ func (_c *ReleaseService_AddItem_Call) Return(err error) *ReleaseService_AddItem_Call

+ func (_c *ReleaseService_AddItem_Call) Run(run func(item *models.ReleaseItem)) *ReleaseService_AddItem_Call

+ func (_c *ReleaseService_AddItem_Call) RunAndReturn(run func(item *models.ReleaseItem) error) *ReleaseService_AddItem_Call

+ type ReleaseService_Create_Call struct

+ func (_c *ReleaseService_Create_Call) Return(err error) *ReleaseService_Create_Call

+ func (_c *ReleaseService_Create_Call) Run(run func(r *models.Release)) *ReleaseService_Create_Call

+ func (_c *ReleaseService_Create_Call) RunAndReturn(run func(r *models.Release) error) *ReleaseService_Create_Call

+ type ReleaseService_Delete_Call struct

+ func (_c *ReleaseService_Delete_Call) Return(err error) *ReleaseService_Delete_Call

+ func (_c *ReleaseService_Delete_Call) Run(run func(id uuid.UUID)) *ReleaseService_Delete_Call

+ func (_c *ReleaseService_Delete_Call) RunAndReturn(run func(id uuid.UUID) error) *ReleaseService_Delete_Call

+ type ReleaseService_Expecter struct

+ func (_e *ReleaseService_Expecter) AddItem(item interface{}) *ReleaseService_AddItem_Call

+ func (_e *ReleaseService_Expecter) Create(r interface{}) *ReleaseService_Create_Call

+ func (_e *ReleaseService_Expecter) Delete(id interface{}) *ReleaseService_Delete_Call

+ func (_e *ReleaseService_Expecter) ListByProject(projectID interface{}) *ReleaseService_ListByProject_Call

+ func (_e *ReleaseService_Expecter) ListByProjectPaged(projectID interface{}, pageInfo interface{}, search interface{}, ...) *ReleaseService_ListByProjectPaged_Call

+ func (_e *ReleaseService_Expecter) ListCandidates(projectID interface{}, releaseID interface{}) *ReleaseService_ListCandidates_Call

+ func (_e *ReleaseService_Expecter) Read(id interface{}) *ReleaseService_Read_Call

+ func (_e *ReleaseService_Expecter) ReadRecursive(id interface{}) *ReleaseService_ReadRecursive_Call

+ func (_e *ReleaseService_Expecter) RemoveItem(id interface{}) *ReleaseService_RemoveItem_Call

+ func (_e *ReleaseService_Expecter) Update(r interface{}) *ReleaseService_Update_Call

+ type ReleaseService_ListByProjectPaged_Call struct

+ func (_c *ReleaseService_ListByProjectPaged_Call) Return(paged shared.Paged[models.Release], err error) *ReleaseService_ListByProjectPaged_Call

+ func (_c *ReleaseService_ListByProjectPaged_Call) Run(run func(projectID uuid.UUID, pageInfo shared.PageInfo, search string, ...)) *ReleaseService_ListByProjectPaged_Call

+ func (_c *ReleaseService_ListByProjectPaged_Call) RunAndReturn(...) *ReleaseService_ListByProjectPaged_Call

+ type ReleaseService_ListByProject_Call struct

+ func (_c *ReleaseService_ListByProject_Call) Return(releases []models.Release, err error) *ReleaseService_ListByProject_Call

+ func (_c *ReleaseService_ListByProject_Call) Run(run func(projectID uuid.UUID)) *ReleaseService_ListByProject_Call

+ func (_c *ReleaseService_ListByProject_Call) RunAndReturn(run func(projectID uuid.UUID) ([]models.Release, error)) *ReleaseService_ListByProject_Call

+ type ReleaseService_ListCandidates_Call struct

+ func (_c *ReleaseService_ListCandidates_Call) Return(artifacts []models.Artifact, releases []models.Release, err error) *ReleaseService_ListCandidates_Call

+ func (_c *ReleaseService_ListCandidates_Call) Run(run func(projectID uuid.UUID, releaseID *uuid.UUID)) *ReleaseService_ListCandidates_Call

+ func (_c *ReleaseService_ListCandidates_Call) RunAndReturn(...) *ReleaseService_ListCandidates_Call

+ type ReleaseService_ReadRecursive_Call struct

+ func (_c *ReleaseService_ReadRecursive_Call) Return(release models.Release, err error) *ReleaseService_ReadRecursive_Call

+ func (_c *ReleaseService_ReadRecursive_Call) Run(run func(id uuid.UUID)) *ReleaseService_ReadRecursive_Call

+ func (_c *ReleaseService_ReadRecursive_Call) RunAndReturn(run func(id uuid.UUID) (models.Release, error)) *ReleaseService_ReadRecursive_Call

+ type ReleaseService_Read_Call struct

+ func (_c *ReleaseService_Read_Call) Return(release models.Release, err error) *ReleaseService_Read_Call

+ func (_c *ReleaseService_Read_Call) Run(run func(id uuid.UUID)) *ReleaseService_Read_Call

+ func (_c *ReleaseService_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.Release, error)) *ReleaseService_Read_Call

+ type ReleaseService_RemoveItem_Call struct

+ func (_c *ReleaseService_RemoveItem_Call) Return(err error) *ReleaseService_RemoveItem_Call

+ func (_c *ReleaseService_RemoveItem_Call) Run(run func(id uuid.UUID)) *ReleaseService_RemoveItem_Call

+ func (_c *ReleaseService_RemoveItem_Call) RunAndReturn(run func(id uuid.UUID) error) *ReleaseService_RemoveItem_Call

+ type ReleaseService_Update_Call struct

+ func (_c *ReleaseService_Update_Call) Return(err error) *ReleaseService_Update_Call

+ func (_c *ReleaseService_Update_Call) Run(run func(r *models.Release)) *ReleaseService_Update_Call

+ func (_c *ReleaseService_Update_Call) RunAndReturn(run func(r *models.Release) error) *ReleaseService_Update_Call

+ type ReportingDescriptorReference struct

+ func NewReportingDescriptorReference(t interface{ ... }) *ReportingDescriptorReference

+ func (_m *ReportingDescriptorReference) EXPECT() *ReportingDescriptorReference_Expecter

+ type ReportingDescriptorReference_Expecter struct

+ type Repository struct

+ func NewRepository[ID any, T utils.Tabler, Tx any](t interface{ ... }) *Repository[ID, T, Tx]

+ func (_m *Repository[ID, T, Tx]) EXPECT() *Repository_Expecter[ID, T, Tx]

+ func (_mock *Repository[ID, T, Tx]) Activate(tx Tx, id ID) error

+ func (_mock *Repository[ID, T, Tx]) All() ([]T, error)

+ func (_mock *Repository[ID, T, Tx]) Begin() Tx

+ func (_mock *Repository[ID, T, Tx]) Create(tx Tx, t *T) error

+ func (_mock *Repository[ID, T, Tx]) CreateBatch(tx Tx, ts []T) error

+ func (_mock *Repository[ID, T, Tx]) Delete(tx Tx, id ID) error

+ func (_mock *Repository[ID, T, Tx]) DeleteBatch(tx Tx, ids []T) error

+ func (_mock *Repository[ID, T, Tx]) GetDB(tx Tx) Tx

+ func (_mock *Repository[ID, T, Tx]) List(ids []ID) ([]T, error)

+ func (_mock *Repository[ID, T, Tx]) Read(id ID) (T, error)

+ func (_mock *Repository[ID, T, Tx]) Save(tx Tx, t *T) error

+ func (_mock *Repository[ID, T, Tx]) SaveBatch(tx Tx, ts []T) error

+ func (_mock *Repository[ID, T, Tx]) SaveBatchBestEffort(tx Tx, ts []T) error

+ func (_mock *Repository[ID, T, Tx]) Transaction(fn func(tx Tx) error) error

+ func (_mock *Repository[ID, T, Tx]) Upsert(t *[]*T, conflictingColumns []clause.Column, updateOnly []string) error

+ type Repository_Activate_Call struct

+ func (_c *Repository_Activate_Call[ID, T, Tx]) Return(err error) *Repository_Activate_Call[ID, T, Tx]

+ func (_c *Repository_Activate_Call[ID, T, Tx]) Run(run func(tx Tx, id ID)) *Repository_Activate_Call[ID, T, Tx]

+ func (_c *Repository_Activate_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, id ID) error) *Repository_Activate_Call[ID, T, Tx]

+ type Repository_All_Call struct

+ func (_c *Repository_All_Call[ID, T, Tx]) Return(vs []T, err error) *Repository_All_Call[ID, T, Tx]

+ func (_c *Repository_All_Call[ID, T, Tx]) Run(run func()) *Repository_All_Call[ID, T, Tx]

+ func (_c *Repository_All_Call[ID, T, Tx]) RunAndReturn(run func() ([]T, error)) *Repository_All_Call[ID, T, Tx]

+ type Repository_Begin_Call struct

+ func (_c *Repository_Begin_Call[ID, T, Tx]) Return(v Tx) *Repository_Begin_Call[ID, T, Tx]

+ func (_c *Repository_Begin_Call[ID, T, Tx]) Run(run func()) *Repository_Begin_Call[ID, T, Tx]

+ func (_c *Repository_Begin_Call[ID, T, Tx]) RunAndReturn(run func() Tx) *Repository_Begin_Call[ID, T, Tx]

+ type Repository_CreateBatch_Call struct

+ func (_c *Repository_CreateBatch_Call[ID, T, Tx]) Return(err error) *Repository_CreateBatch_Call[ID, T, Tx]

+ func (_c *Repository_CreateBatch_Call[ID, T, Tx]) Run(run func(tx Tx, ts []T)) *Repository_CreateBatch_Call[ID, T, Tx]

+ func (_c *Repository_CreateBatch_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, ts []T) error) *Repository_CreateBatch_Call[ID, T, Tx]

+ type Repository_Create_Call struct

+ func (_c *Repository_Create_Call[ID, T, Tx]) Return(err error) *Repository_Create_Call[ID, T, Tx]

+ func (_c *Repository_Create_Call[ID, T, Tx]) Run(run func(tx Tx, t *T)) *Repository_Create_Call[ID, T, Tx]

+ func (_c *Repository_Create_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, t *T) error) *Repository_Create_Call[ID, T, Tx]

+ type Repository_DeleteBatch_Call struct

+ func (_c *Repository_DeleteBatch_Call[ID, T, Tx]) Return(err error) *Repository_DeleteBatch_Call[ID, T, Tx]

+ func (_c *Repository_DeleteBatch_Call[ID, T, Tx]) Run(run func(tx Tx, ids []T)) *Repository_DeleteBatch_Call[ID, T, Tx]

+ func (_c *Repository_DeleteBatch_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, ids []T) error) *Repository_DeleteBatch_Call[ID, T, Tx]

+ type Repository_Delete_Call struct

+ func (_c *Repository_Delete_Call[ID, T, Tx]) Return(err error) *Repository_Delete_Call[ID, T, Tx]

+ func (_c *Repository_Delete_Call[ID, T, Tx]) Run(run func(tx Tx, id ID)) *Repository_Delete_Call[ID, T, Tx]

+ func (_c *Repository_Delete_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, id ID) error) *Repository_Delete_Call[ID, T, Tx]

+ type Repository_Expecter struct

+ func (_e *Repository_Expecter[ID, T, Tx]) Activate(tx interface{}, id interface{}) *Repository_Activate_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) All() *Repository_All_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) Begin() *Repository_Begin_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) Create(tx interface{}, t interface{}) *Repository_Create_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) CreateBatch(tx interface{}, ts interface{}) *Repository_CreateBatch_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) Delete(tx interface{}, id interface{}) *Repository_Delete_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) DeleteBatch(tx interface{}, ids interface{}) *Repository_DeleteBatch_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) GetDB(tx interface{}) *Repository_GetDB_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) List(ids interface{}) *Repository_List_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) Read(id interface{}) *Repository_Read_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) Save(tx interface{}, t interface{}) *Repository_Save_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) SaveBatch(tx interface{}, ts interface{}) *Repository_SaveBatch_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) SaveBatchBestEffort(tx interface{}, ts interface{}) *Repository_SaveBatchBestEffort_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) Transaction(fn interface{}) *Repository_Transaction_Call[ID, T, Tx]

+ func (_e *Repository_Expecter[ID, T, Tx]) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *Repository_Upsert_Call[ID, T, Tx]

+ type Repository_GetDB_Call struct

+ func (_c *Repository_GetDB_Call[ID, T, Tx]) Return(v Tx) *Repository_GetDB_Call[ID, T, Tx]

+ func (_c *Repository_GetDB_Call[ID, T, Tx]) Run(run func(tx Tx)) *Repository_GetDB_Call[ID, T, Tx]

+ func (_c *Repository_GetDB_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx) Tx) *Repository_GetDB_Call[ID, T, Tx]

+ type Repository_List_Call struct

+ func (_c *Repository_List_Call[ID, T, Tx]) Return(vs []T, err error) *Repository_List_Call[ID, T, Tx]

+ func (_c *Repository_List_Call[ID, T, Tx]) Run(run func(ids []ID)) *Repository_List_Call[ID, T, Tx]

+ func (_c *Repository_List_Call[ID, T, Tx]) RunAndReturn(run func(ids []ID) ([]T, error)) *Repository_List_Call[ID, T, Tx]

+ type Repository_Read_Call struct

+ func (_c *Repository_Read_Call[ID, T, Tx]) Return(v T, err error) *Repository_Read_Call[ID, T, Tx]

+ func (_c *Repository_Read_Call[ID, T, Tx]) Run(run func(id ID)) *Repository_Read_Call[ID, T, Tx]

+ func (_c *Repository_Read_Call[ID, T, Tx]) RunAndReturn(run func(id ID) (T, error)) *Repository_Read_Call[ID, T, Tx]

+ type Repository_SaveBatchBestEffort_Call struct

+ func (_c *Repository_SaveBatchBestEffort_Call[ID, T, Tx]) Return(err error) *Repository_SaveBatchBestEffort_Call[ID, T, Tx]

+ func (_c *Repository_SaveBatchBestEffort_Call[ID, T, Tx]) Run(run func(tx Tx, ts []T)) *Repository_SaveBatchBestEffort_Call[ID, T, Tx]

+ func (_c *Repository_SaveBatchBestEffort_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, ts []T) error) *Repository_SaveBatchBestEffort_Call[ID, T, Tx]

+ type Repository_SaveBatch_Call struct

+ func (_c *Repository_SaveBatch_Call[ID, T, Tx]) Return(err error) *Repository_SaveBatch_Call[ID, T, Tx]

+ func (_c *Repository_SaveBatch_Call[ID, T, Tx]) Run(run func(tx Tx, ts []T)) *Repository_SaveBatch_Call[ID, T, Tx]

+ func (_c *Repository_SaveBatch_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, ts []T) error) *Repository_SaveBatch_Call[ID, T, Tx]

+ type Repository_Save_Call struct

+ func (_c *Repository_Save_Call[ID, T, Tx]) Return(err error) *Repository_Save_Call[ID, T, Tx]

+ func (_c *Repository_Save_Call[ID, T, Tx]) Run(run func(tx Tx, t *T)) *Repository_Save_Call[ID, T, Tx]

+ func (_c *Repository_Save_Call[ID, T, Tx]) RunAndReturn(run func(tx Tx, t *T) error) *Repository_Save_Call[ID, T, Tx]

+ type Repository_Transaction_Call struct

+ func (_c *Repository_Transaction_Call[ID, T, Tx]) Return(err error) *Repository_Transaction_Call[ID, T, Tx]

+ func (_c *Repository_Transaction_Call[ID, T, Tx]) Run(run func(fn func(tx Tx) error)) *Repository_Transaction_Call[ID, T, Tx]

+ func (_c *Repository_Transaction_Call[ID, T, Tx]) RunAndReturn(run func(fn func(tx Tx) error) error) *Repository_Transaction_Call[ID, T, Tx]

+ type Repository_Upsert_Call struct

+ func (_c *Repository_Upsert_Call[ID, T, Tx]) Return(err error) *Repository_Upsert_Call[ID, T, Tx]

+ func (_c *Repository_Upsert_Call[ID, T, Tx]) Run(run func(t *[]*T, conflictingColumns []clause.Column, updateOnly []string)) *Repository_Upsert_Call[ID, T, Tx]

+ func (_c *Repository_Upsert_Call[ID, T, Tx]) RunAndReturn(...) *Repository_Upsert_Call[ID, T, Tx]

+ type RequestSigner struct

+ func NewRequestSigner(t interface{ ... }) *RequestSigner

+ func (_m *RequestSigner) EXPECT() *RequestSigner_Expecter

+ func (_mock *RequestSigner) SignRequest(token string, req *http.Request) error

+ type RequestSigner_Expecter struct

+ func (_e *RequestSigner_Expecter) SignRequest(token interface{}, req interface{}) *RequestSigner_SignRequest_Call

+ type RequestSigner_SignRequest_Call struct

+ func (_c *RequestSigner_SignRequest_Call) Return(err error) *RequestSigner_SignRequest_Call

+ func (_c *RequestSigner_SignRequest_Call) Run(run func(token string, req *http.Request)) *RequestSigner_SignRequest_Call

+ func (_c *RequestSigner_SignRequest_Call) RunAndReturn(run func(token string, req *http.Request) error) *RequestSigner_SignRequest_Call

type ScanService

+ func (_mock *ScanService) FetchSbomsFromUpstream(artifactName string, ref string, upstreamURLs []string, ...) ([]*normalize.SBOMGraph, []string, []dtos.ExternalReferenceError)

+ func (_mock *ScanService) FetchVexFromUpstream(upstreamURLs []models.ExternalReference) ([]*normalize.VexReport, []models.ExternalReference, []models.ExternalReference)

+ func (_mock *ScanService) HandleFirstPartyVulnResult(org models.Org, project models.Project, asset models.Asset, ...) ([]models.FirstPartyVuln, []models.FirstPartyVuln, []models.FirstPartyVuln, ...)

+ func (_mock *ScanService) HandleScanResult(tx shared.DB, org models.Org, project models.Project, asset models.Asset, ...) ([]models.DependencyVuln, []models.DependencyVuln, []models.DependencyVuln, ...)

+ func (_mock *ScanService) RunArtifactSecurityLifecycle(tx shared.DB, org models.Org, project models.Project, asset models.Asset, ...) (*normalize.SBOMGraph, []*normalize.VexReport, []models.DependencyVuln, error)

type ScanService_Expecter

+ func (_e *ScanService_Expecter) FetchSbomsFromUpstream(artifactName interface{}, ref interface{}, upstreamURLs interface{}, ...) *ScanService_FetchSbomsFromUpstream_Call

+ func (_e *ScanService_Expecter) FetchVexFromUpstream(upstreamURLs interface{}) *ScanService_FetchVexFromUpstream_Call

+ func (_e *ScanService_Expecter) HandleFirstPartyVulnResult(org interface{}, project interface{}, asset interface{}, ...) *ScanService_HandleFirstPartyVulnResult_Call

+ func (_e *ScanService_Expecter) HandleScanResult(tx interface{}, org interface{}, project interface{}, asset interface{}, ...) *ScanService_HandleScanResult_Call

+ func (_e *ScanService_Expecter) RunArtifactSecurityLifecycle(tx interface{}, org interface{}, project interface{}, asset interface{}, ...) *ScanService_RunArtifactSecurityLifecycle_Call

+ type ScanService_FetchSbomsFromUpstream_Call struct

+ func (_c *ScanService_FetchSbomsFromUpstream_Call) Return(sBOMGraphs []*normalize.SBOMGraph, strings []string, ...) *ScanService_FetchSbomsFromUpstream_Call

+ func (_c *ScanService_FetchSbomsFromUpstream_Call) Run(run func(artifactName string, ref string, upstreamURLs []string, ...)) *ScanService_FetchSbomsFromUpstream_Call

+ func (_c *ScanService_FetchSbomsFromUpstream_Call) RunAndReturn(...) *ScanService_FetchSbomsFromUpstream_Call

+ type ScanService_FetchVexFromUpstream_Call struct

+ func (_c *ScanService_FetchVexFromUpstream_Call) Return(vexReports []*normalize.VexReport, ...) *ScanService_FetchVexFromUpstream_Call

+ func (_c *ScanService_FetchVexFromUpstream_Call) Run(run func(upstreamURLs []models.ExternalReference)) *ScanService_FetchVexFromUpstream_Call

+ func (_c *ScanService_FetchVexFromUpstream_Call) RunAndReturn(...) *ScanService_FetchVexFromUpstream_Call

+ type ScanService_HandleFirstPartyVulnResult_Call struct

+ func (_c *ScanService_HandleFirstPartyVulnResult_Call) Return(firstPartyVulns []models.FirstPartyVuln, ...) *ScanService_HandleFirstPartyVulnResult_Call

+ func (_c *ScanService_HandleFirstPartyVulnResult_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *ScanService_HandleFirstPartyVulnResult_Call

+ func (_c *ScanService_HandleFirstPartyVulnResult_Call) RunAndReturn(...) *ScanService_HandleFirstPartyVulnResult_Call

+ type ScanService_HandleScanResult_Call struct

+ func (_c *ScanService_HandleScanResult_Call) Return(opened []models.DependencyVuln, closed []models.DependencyVuln, ...) *ScanService_HandleScanResult_Call

+ func (_c *ScanService_HandleScanResult_Call) Run(...) *ScanService_HandleScanResult_Call

+ func (_c *ScanService_HandleScanResult_Call) RunAndReturn(...) *ScanService_HandleScanResult_Call

+ type ScanService_RunArtifactSecurityLifecycle_Call struct

+ func (_c *ScanService_RunArtifactSecurityLifecycle_Call) Return(sBOMGraph *normalize.SBOMGraph, vexReports []*normalize.VexReport, ...) *ScanService_RunArtifactSecurityLifecycle_Call

+ func (_c *ScanService_RunArtifactSecurityLifecycle_Call) Run(...) *ScanService_RunArtifactSecurityLifecycle_Call

+ func (_c *ScanService_RunArtifactSecurityLifecycle_Call) RunAndReturn(...) *ScanService_RunArtifactSecurityLifecycle_Call

+ type Slugger struct

+ func NewSlugger[T any](t interface{ ... }) *Slugger[T]

+ func (_m *Slugger[T]) EXPECT() *Slugger_Expecter[T]

+ func (_mock *Slugger[T]) GetSlug() string

+ func (_mock *Slugger[T]) Same(v T) bool

+ func (_mock *Slugger[T]) SetSlug(s string)

+ type Slugger_Expecter struct

+ func (_e *Slugger_Expecter[T]) GetSlug() *Slugger_GetSlug_Call[T]

+ func (_e *Slugger_Expecter[T]) Same(v interface{}) *Slugger_Same_Call[T]

+ func (_e *Slugger_Expecter[T]) SetSlug(s interface{}) *Slugger_SetSlug_Call[T]

+ type Slugger_GetSlug_Call struct

+ func (_c *Slugger_GetSlug_Call[T]) Return(s string) *Slugger_GetSlug_Call[T]

+ func (_c *Slugger_GetSlug_Call[T]) Run(run func()) *Slugger_GetSlug_Call[T]

+ func (_c *Slugger_GetSlug_Call[T]) RunAndReturn(run func() string) *Slugger_GetSlug_Call[T]

+ type Slugger_Same_Call struct

+ func (_c *Slugger_Same_Call[T]) Return(b bool) *Slugger_Same_Call[T]

+ func (_c *Slugger_Same_Call[T]) Run(run func(v T)) *Slugger_Same_Call[T]

+ func (_c *Slugger_Same_Call[T]) RunAndReturn(run func(v T) bool) *Slugger_Same_Call[T]

+ type Slugger_SetSlug_Call struct

+ func (_c *Slugger_SetSlug_Call[T]) Return() *Slugger_SetSlug_Call[T]

+ func (_c *Slugger_SetSlug_Call[T]) Run(run func(s string)) *Slugger_SetSlug_Call[T]

+ func (_c *Slugger_SetSlug_Call[T]) RunAndReturn(run func(s string)) *Slugger_SetSlug_Call[T]

type SupplyChainRepository

+ func (_mock *SupplyChainRepository) SaveBatchBestEffort(tx shared.DB, ts []models.SupplyChain) error

type SupplyChainRepository_Expecter

+ func (_e *SupplyChainRepository_Expecter) SaveBatchBestEffort(tx interface{}, ts interface{}) *SupplyChainRepository_SaveBatchBestEffort_Call

+ type SupplyChainRepository_SaveBatchBestEffort_Call struct

+ func (_c *SupplyChainRepository_SaveBatchBestEffort_Call) Return(err error) *SupplyChainRepository_SaveBatchBestEffort_Call

+ func (_c *SupplyChainRepository_SaveBatchBestEffort_Call) Run(run func(tx shared.DB, ts []models.SupplyChain)) *SupplyChainRepository_SaveBatchBestEffort_Call

+ func (_c *SupplyChainRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(tx shared.DB, ts []models.SupplyChain) error) *SupplyChainRepository_SaveBatchBestEffort_Call

+ type Tabler struct

+ func NewTabler(t interface{ ... }) *Tabler

+ func (_m *Tabler) EXPECT() *Tabler_Expecter

+ func (_mock *Tabler) TableName() string

+ type Tabler_Expecter struct

+ func (_e *Tabler_Expecter) TableName() *Tabler_TableName_Call

+ type Tabler_TableName_Call struct

+ func (_c *Tabler_TableName_Call) Return(s string) *Tabler_TableName_Call

+ func (_c *Tabler_TableName_Call) Run(run func()) *Tabler_TableName_Call

+ func (_c *Tabler_TableName_Call) RunAndReturn(run func() string) *Tabler_TableName_Call

type ThirdPartyIntegration

+ func (_mock *ThirdPartyIntegration) CompareIssueStatesAndResolveDifferences(asset models.Asset, vulnsWithTickets []models.DependencyVuln) error

+ type ThirdPartyIntegration_CompareIssueStatesAndResolveDifferences_Call struct

+ func (_c *ThirdPartyIntegration_CompareIssueStatesAndResolveDifferences_Call) Return(err error) *ThirdPartyIntegration_CompareIssueStatesAndResolveDifferences_Call

+ func (_c *ThirdPartyIntegration_CompareIssueStatesAndResolveDifferences_Call) Run(run func(asset models.Asset, vulnsWithTickets []models.DependencyVuln)) *ThirdPartyIntegration_CompareIssueStatesAndResolveDifferences_Call

+ func (_c *ThirdPartyIntegration_CompareIssueStatesAndResolveDifferences_Call) RunAndReturn(run func(asset models.Asset, vulnsWithTickets []models.DependencyVuln) error) *ThirdPartyIntegration_CompareIssueStatesAndResolveDifferences_Call

type ThirdPartyIntegration_Expecter

+ func (_e *ThirdPartyIntegration_Expecter) CompareIssueStatesAndResolveDifferences(asset interface{}, vulnsWithTickets interface{}) *ThirdPartyIntegration_CompareIssueStatesAndResolveDifferences_Call

+ type Transactioner struct

+ func NewTransactioner[Tx any](t interface{ ... }) *Transactioner[Tx]

+ func (_m *Transactioner[Tx]) EXPECT() *Transactioner_Expecter[Tx]

+ func (_mock *Transactioner[Tx]) Begin() Tx

+ func (_mock *Transactioner[Tx]) GetDB(tx Tx) Tx

+ func (_mock *Transactioner[Tx]) Transaction(fn func(tx Tx) error) error

+ type Transactioner_Begin_Call struct

+ func (_c *Transactioner_Begin_Call[Tx]) Return(v Tx) *Transactioner_Begin_Call[Tx]

+ func (_c *Transactioner_Begin_Call[Tx]) Run(run func()) *Transactioner_Begin_Call[Tx]

+ func (_c *Transactioner_Begin_Call[Tx]) RunAndReturn(run func() Tx) *Transactioner_Begin_Call[Tx]

+ type Transactioner_Expecter struct

+ func (_e *Transactioner_Expecter[Tx]) Begin() *Transactioner_Begin_Call[Tx]

+ func (_e *Transactioner_Expecter[Tx]) GetDB(tx interface{}) *Transactioner_GetDB_Call[Tx]

+ func (_e *Transactioner_Expecter[Tx]) Transaction(fn interface{}) *Transactioner_Transaction_Call[Tx]

+ type Transactioner_GetDB_Call struct

+ func (_c *Transactioner_GetDB_Call[Tx]) Return(v Tx) *Transactioner_GetDB_Call[Tx]

+ func (_c *Transactioner_GetDB_Call[Tx]) Run(run func(tx Tx)) *Transactioner_GetDB_Call[Tx]

+ func (_c *Transactioner_GetDB_Call[Tx]) RunAndReturn(run func(tx Tx) Tx) *Transactioner_GetDB_Call[Tx]

+ type Transactioner_Transaction_Call struct

+ func (_c *Transactioner_Transaction_Call[Tx]) Return(err error) *Transactioner_Transaction_Call[Tx]

+ func (_c *Transactioner_Transaction_Call[Tx]) Run(run func(fn func(tx Tx) error)) *Transactioner_Transaction_Call[Tx]

+ func (_c *Transactioner_Transaction_Call[Tx]) RunAndReturn(run func(fn func(tx Tx) error) error) *Transactioner_Transaction_Call[Tx]

+ type VEXRuleRepository struct

+ func NewVEXRuleRepository(t interface{ ... }) *VEXRuleRepository

+ func (_m *VEXRuleRepository) EXPECT() *VEXRuleRepository_Expecter

+ func (_mock *VEXRuleRepository) Begin() shared.DB

+ func (_mock *VEXRuleRepository) Create(db shared.DB, rule *models.VEXRule) error

+ func (_mock *VEXRuleRepository) Delete(db shared.DB, rule models.VEXRule) error

+ func (_mock *VEXRuleRepository) DeleteBatch(db shared.DB, rules []models.VEXRule) error

+ func (_mock *VEXRuleRepository) DeleteByAssetVersion(db shared.DB, assetID uuid.UUID, assetVersionName string) error

+ func (_mock *VEXRuleRepository) FindByAssetAndVexSource(db shared.DB, assetID uuid.UUID, vexSource string) ([]models.VEXRule, error)

+ func (_mock *VEXRuleRepository) FindByAssetVersion(db shared.DB, assetID uuid.UUID, assetVersionName string) ([]models.VEXRule, error)

+ func (_mock *VEXRuleRepository) FindByAssetVersionAndCVE(db shared.DB, assetID uuid.UUID, assetVersionName string, cveID string) ([]models.VEXRule, error)

+ func (_mock *VEXRuleRepository) FindByAssetVersionPaged(db shared.DB, assetID uuid.UUID, assetVersionName string, ...) (shared.Paged[models.VEXRule], error)

+ func (_mock *VEXRuleRepository) FindByID(db shared.DB, id string) (models.VEXRule, error)

+ func (_mock *VEXRuleRepository) GetDB(db shared.DB) shared.DB

+ func (_mock *VEXRuleRepository) Update(db shared.DB, rule *models.VEXRule) error

+ func (_mock *VEXRuleRepository) Upsert(db shared.DB, rule *models.VEXRule) error

+ func (_mock *VEXRuleRepository) UpsertBatch(db shared.DB, rules []models.VEXRule) error

+ type VEXRuleRepository_Begin_Call struct

+ func (_c *VEXRuleRepository_Begin_Call) Return(v shared.DB) *VEXRuleRepository_Begin_Call

+ func (_c *VEXRuleRepository_Begin_Call) Run(run func()) *VEXRuleRepository_Begin_Call

+ func (_c *VEXRuleRepository_Begin_Call) RunAndReturn(run func() shared.DB) *VEXRuleRepository_Begin_Call

+ type VEXRuleRepository_Create_Call struct

+ func (_c *VEXRuleRepository_Create_Call) Return(err error) *VEXRuleRepository_Create_Call

+ func (_c *VEXRuleRepository_Create_Call) Run(run func(db shared.DB, rule *models.VEXRule)) *VEXRuleRepository_Create_Call

+ func (_c *VEXRuleRepository_Create_Call) RunAndReturn(run func(db shared.DB, rule *models.VEXRule) error) *VEXRuleRepository_Create_Call

+ type VEXRuleRepository_DeleteBatch_Call struct

+ func (_c *VEXRuleRepository_DeleteBatch_Call) Return(err error) *VEXRuleRepository_DeleteBatch_Call

+ func (_c *VEXRuleRepository_DeleteBatch_Call) Run(run func(db shared.DB, rules []models.VEXRule)) *VEXRuleRepository_DeleteBatch_Call

+ func (_c *VEXRuleRepository_DeleteBatch_Call) RunAndReturn(run func(db shared.DB, rules []models.VEXRule) error) *VEXRuleRepository_DeleteBatch_Call

+ type VEXRuleRepository_DeleteByAssetVersion_Call struct

+ func (_c *VEXRuleRepository_DeleteByAssetVersion_Call) Return(err error) *VEXRuleRepository_DeleteByAssetVersion_Call

+ func (_c *VEXRuleRepository_DeleteByAssetVersion_Call) Run(run func(db shared.DB, assetID uuid.UUID, assetVersionName string)) *VEXRuleRepository_DeleteByAssetVersion_Call

+ func (_c *VEXRuleRepository_DeleteByAssetVersion_Call) RunAndReturn(run func(db shared.DB, assetID uuid.UUID, assetVersionName string) error) *VEXRuleRepository_DeleteByAssetVersion_Call

+ type VEXRuleRepository_Delete_Call struct

+ func (_c *VEXRuleRepository_Delete_Call) Return(err error) *VEXRuleRepository_Delete_Call

+ func (_c *VEXRuleRepository_Delete_Call) Run(run func(db shared.DB, rule models.VEXRule)) *VEXRuleRepository_Delete_Call

+ func (_c *VEXRuleRepository_Delete_Call) RunAndReturn(run func(db shared.DB, rule models.VEXRule) error) *VEXRuleRepository_Delete_Call

+ type VEXRuleRepository_Expecter struct

+ func (_e *VEXRuleRepository_Expecter) Begin() *VEXRuleRepository_Begin_Call

+ func (_e *VEXRuleRepository_Expecter) Create(db interface{}, rule interface{}) *VEXRuleRepository_Create_Call

+ func (_e *VEXRuleRepository_Expecter) Delete(db interface{}, rule interface{}) *VEXRuleRepository_Delete_Call

+ func (_e *VEXRuleRepository_Expecter) DeleteBatch(db interface{}, rules interface{}) *VEXRuleRepository_DeleteBatch_Call

+ func (_e *VEXRuleRepository_Expecter) DeleteByAssetVersion(db interface{}, assetID interface{}, assetVersionName interface{}) *VEXRuleRepository_DeleteByAssetVersion_Call

+ func (_e *VEXRuleRepository_Expecter) FindByAssetAndVexSource(db interface{}, assetID interface{}, vexSource interface{}) *VEXRuleRepository_FindByAssetAndVexSource_Call

+ func (_e *VEXRuleRepository_Expecter) FindByAssetVersion(db interface{}, assetID interface{}, assetVersionName interface{}) *VEXRuleRepository_FindByAssetVersion_Call

+ func (_e *VEXRuleRepository_Expecter) FindByAssetVersionAndCVE(db interface{}, assetID interface{}, assetVersionName interface{}, ...) *VEXRuleRepository_FindByAssetVersionAndCVE_Call

+ func (_e *VEXRuleRepository_Expecter) FindByAssetVersionPaged(db interface{}, assetID interface{}, assetVersionName interface{}, ...) *VEXRuleRepository_FindByAssetVersionPaged_Call

+ func (_e *VEXRuleRepository_Expecter) FindByID(db interface{}, id interface{}) *VEXRuleRepository_FindByID_Call

+ func (_e *VEXRuleRepository_Expecter) GetDB(db interface{}) *VEXRuleRepository_GetDB_Call

+ func (_e *VEXRuleRepository_Expecter) Update(db interface{}, rule interface{}) *VEXRuleRepository_Update_Call

+ func (_e *VEXRuleRepository_Expecter) Upsert(db interface{}, rule interface{}) *VEXRuleRepository_Upsert_Call

+ func (_e *VEXRuleRepository_Expecter) UpsertBatch(db interface{}, rules interface{}) *VEXRuleRepository_UpsertBatch_Call

+ type VEXRuleRepository_FindByAssetAndVexSource_Call struct

+ func (_c *VEXRuleRepository_FindByAssetAndVexSource_Call) Return(vEXRules []models.VEXRule, err error) *VEXRuleRepository_FindByAssetAndVexSource_Call

+ func (_c *VEXRuleRepository_FindByAssetAndVexSource_Call) Run(run func(db shared.DB, assetID uuid.UUID, vexSource string)) *VEXRuleRepository_FindByAssetAndVexSource_Call

+ func (_c *VEXRuleRepository_FindByAssetAndVexSource_Call) RunAndReturn(...) *VEXRuleRepository_FindByAssetAndVexSource_Call

+ type VEXRuleRepository_FindByAssetVersionAndCVE_Call struct

+ func (_c *VEXRuleRepository_FindByAssetVersionAndCVE_Call) Return(vEXRules []models.VEXRule, err error) *VEXRuleRepository_FindByAssetVersionAndCVE_Call

+ func (_c *VEXRuleRepository_FindByAssetVersionAndCVE_Call) Run(...) *VEXRuleRepository_FindByAssetVersionAndCVE_Call

+ func (_c *VEXRuleRepository_FindByAssetVersionAndCVE_Call) RunAndReturn(...) *VEXRuleRepository_FindByAssetVersionAndCVE_Call

+ type VEXRuleRepository_FindByAssetVersionPaged_Call struct

+ func (_c *VEXRuleRepository_FindByAssetVersionPaged_Call) Return(paged shared.Paged[models.VEXRule], err error) *VEXRuleRepository_FindByAssetVersionPaged_Call

+ func (_c *VEXRuleRepository_FindByAssetVersionPaged_Call) Run(run func(db shared.DB, assetID uuid.UUID, assetVersionName string, ...)) *VEXRuleRepository_FindByAssetVersionPaged_Call

+ func (_c *VEXRuleRepository_FindByAssetVersionPaged_Call) RunAndReturn(...) *VEXRuleRepository_FindByAssetVersionPaged_Call

+ type VEXRuleRepository_FindByAssetVersion_Call struct

+ func (_c *VEXRuleRepository_FindByAssetVersion_Call) Return(vEXRules []models.VEXRule, err error) *VEXRuleRepository_FindByAssetVersion_Call

+ func (_c *VEXRuleRepository_FindByAssetVersion_Call) Run(run func(db shared.DB, assetID uuid.UUID, assetVersionName string)) *VEXRuleRepository_FindByAssetVersion_Call

+ func (_c *VEXRuleRepository_FindByAssetVersion_Call) RunAndReturn(...) *VEXRuleRepository_FindByAssetVersion_Call

+ type VEXRuleRepository_FindByID_Call struct

+ func (_c *VEXRuleRepository_FindByID_Call) Return(vEXRule models.VEXRule, err error) *VEXRuleRepository_FindByID_Call

+ func (_c *VEXRuleRepository_FindByID_Call) Run(run func(db shared.DB, id string)) *VEXRuleRepository_FindByID_Call

+ func (_c *VEXRuleRepository_FindByID_Call) RunAndReturn(run func(db shared.DB, id string) (models.VEXRule, error)) *VEXRuleRepository_FindByID_Call

+ type VEXRuleRepository_GetDB_Call struct

+ func (_c *VEXRuleRepository_GetDB_Call) Return(v shared.DB) *VEXRuleRepository_GetDB_Call

+ func (_c *VEXRuleRepository_GetDB_Call) Run(run func(db shared.DB)) *VEXRuleRepository_GetDB_Call

+ func (_c *VEXRuleRepository_GetDB_Call) RunAndReturn(run func(db shared.DB) shared.DB) *VEXRuleRepository_GetDB_Call

+ type VEXRuleRepository_Update_Call struct

+ func (_c *VEXRuleRepository_Update_Call) Return(err error) *VEXRuleRepository_Update_Call

+ func (_c *VEXRuleRepository_Update_Call) Run(run func(db shared.DB, rule *models.VEXRule)) *VEXRuleRepository_Update_Call

+ func (_c *VEXRuleRepository_Update_Call) RunAndReturn(run func(db shared.DB, rule *models.VEXRule) error) *VEXRuleRepository_Update_Call

+ type VEXRuleRepository_UpsertBatch_Call struct

+ func (_c *VEXRuleRepository_UpsertBatch_Call) Return(err error) *VEXRuleRepository_UpsertBatch_Call

+ func (_c *VEXRuleRepository_UpsertBatch_Call) Run(run func(db shared.DB, rules []models.VEXRule)) *VEXRuleRepository_UpsertBatch_Call

+ func (_c *VEXRuleRepository_UpsertBatch_Call) RunAndReturn(run func(db shared.DB, rules []models.VEXRule) error) *VEXRuleRepository_UpsertBatch_Call

+ type VEXRuleRepository_Upsert_Call struct

+ func (_c *VEXRuleRepository_Upsert_Call) Return(err error) *VEXRuleRepository_Upsert_Call

+ func (_c *VEXRuleRepository_Upsert_Call) Run(run func(db shared.DB, rule *models.VEXRule)) *VEXRuleRepository_Upsert_Call

+ func (_c *VEXRuleRepository_Upsert_Call) RunAndReturn(run func(db shared.DB, rule *models.VEXRule) error) *VEXRuleRepository_Upsert_Call

+ type VEXRuleService struct

+ func NewVEXRuleService(t interface{ ... }) *VEXRuleService

+ func (_m *VEXRuleService) EXPECT() *VEXRuleService_Expecter

+ func (_mock *VEXRuleService) ApplyRulesToExisting(tx shared.DB, rules []models.VEXRule, vulns []models.DependencyVuln) ([]models.DependencyVuln, error)

+ func (_mock *VEXRuleService) ApplyRulesToExistingForce(tx shared.DB, rules []models.VEXRule, vulns []models.DependencyVuln) ([]models.DependencyVuln, error)

+ func (_mock *VEXRuleService) ApplyRulesToExistingVulns(tx shared.DB, rules []models.VEXRule) ([]models.DependencyVuln, error)

+ func (_mock *VEXRuleService) ApplyRulesToExistingVulnsForce(tx shared.DB, rules []models.VEXRule) ([]models.DependencyVuln, error)

+ func (_mock *VEXRuleService) Begin() shared.DB

+ func (_mock *VEXRuleService) CountMatchingVulns(tx shared.DB, rule models.VEXRule) (int, error)

+ func (_mock *VEXRuleService) CountMatchingVulnsForRules(tx shared.DB, rules []models.VEXRule) (map[string]int, error)

+ func (_mock *VEXRuleService) Create(tx shared.DB, rule *models.VEXRule) error

+ func (_mock *VEXRuleService) Delete(tx shared.DB, rule models.VEXRule) error

+ func (_mock *VEXRuleService) DeleteByAssetVersion(tx shared.DB, assetID uuid.UUID, assetVersionName string) error

+ func (_mock *VEXRuleService) FindByAssetVersion(tx shared.DB, assetID uuid.UUID, assetVersionName string) ([]models.VEXRule, error)

+ func (_mock *VEXRuleService) FindByAssetVersionAndCVE(tx shared.DB, assetID uuid.UUID, assetVersionName string, cveID string) ([]models.VEXRule, error)

+ func (_mock *VEXRuleService) FindByAssetVersionAndVulnID(tx shared.DB, assetID uuid.UUID, assetVersionName string, vulnID string) ([]models.VEXRule, error)

+ func (_mock *VEXRuleService) FindByAssetVersionPaged(tx shared.DB, assetID uuid.UUID, assetVersionName string, ...) (shared.Paged[models.VEXRule], error)

+ func (_mock *VEXRuleService) FindByID(tx shared.DB, id string) (models.VEXRule, error)

+ func (_mock *VEXRuleService) IngestVEX(tx shared.DB, asset models.Asset, assetVersion models.AssetVersion, ...) error

+ func (_mock *VEXRuleService) IngestVexes(tx shared.DB, asset models.Asset, assetVersion models.AssetVersion, ...) error

+ func (_mock *VEXRuleService) Update(tx shared.DB, rule *models.VEXRule) error

+ type VEXRuleService_ApplyRulesToExistingForce_Call struct

+ func (_c *VEXRuleService_ApplyRulesToExistingForce_Call) Return(dependencyVulns []models.DependencyVuln, err error) *VEXRuleService_ApplyRulesToExistingForce_Call

+ func (_c *VEXRuleService_ApplyRulesToExistingForce_Call) Run(run func(tx shared.DB, rules []models.VEXRule, vulns []models.DependencyVuln)) *VEXRuleService_ApplyRulesToExistingForce_Call

+ func (_c *VEXRuleService_ApplyRulesToExistingForce_Call) RunAndReturn(...) *VEXRuleService_ApplyRulesToExistingForce_Call

+ type VEXRuleService_ApplyRulesToExistingVulnsForce_Call struct

+ func (_c *VEXRuleService_ApplyRulesToExistingVulnsForce_Call) Return(dependencyVulns []models.DependencyVuln, err error) *VEXRuleService_ApplyRulesToExistingVulnsForce_Call

+ func (_c *VEXRuleService_ApplyRulesToExistingVulnsForce_Call) Run(run func(tx shared.DB, rules []models.VEXRule)) *VEXRuleService_ApplyRulesToExistingVulnsForce_Call

+ func (_c *VEXRuleService_ApplyRulesToExistingVulnsForce_Call) RunAndReturn(...) *VEXRuleService_ApplyRulesToExistingVulnsForce_Call

+ type VEXRuleService_ApplyRulesToExistingVulns_Call struct

+ func (_c *VEXRuleService_ApplyRulesToExistingVulns_Call) Return(dependencyVulns []models.DependencyVuln, err error) *VEXRuleService_ApplyRulesToExistingVulns_Call

+ func (_c *VEXRuleService_ApplyRulesToExistingVulns_Call) Run(run func(tx shared.DB, rules []models.VEXRule)) *VEXRuleService_ApplyRulesToExistingVulns_Call

+ func (_c *VEXRuleService_ApplyRulesToExistingVulns_Call) RunAndReturn(...) *VEXRuleService_ApplyRulesToExistingVulns_Call

+ type VEXRuleService_ApplyRulesToExisting_Call struct

+ func (_c *VEXRuleService_ApplyRulesToExisting_Call) Return(dependencyVulns []models.DependencyVuln, err error) *VEXRuleService_ApplyRulesToExisting_Call

+ func (_c *VEXRuleService_ApplyRulesToExisting_Call) Run(run func(tx shared.DB, rules []models.VEXRule, vulns []models.DependencyVuln)) *VEXRuleService_ApplyRulesToExisting_Call

+ func (_c *VEXRuleService_ApplyRulesToExisting_Call) RunAndReturn(...) *VEXRuleService_ApplyRulesToExisting_Call

+ type VEXRuleService_Begin_Call struct

+ func (_c *VEXRuleService_Begin_Call) Return(v shared.DB) *VEXRuleService_Begin_Call

+ func (_c *VEXRuleService_Begin_Call) Run(run func()) *VEXRuleService_Begin_Call

+ func (_c *VEXRuleService_Begin_Call) RunAndReturn(run func() shared.DB) *VEXRuleService_Begin_Call

+ type VEXRuleService_CountMatchingVulnsForRules_Call struct

+ func (_c *VEXRuleService_CountMatchingVulnsForRules_Call) Return(stringToInt map[string]int, err error) *VEXRuleService_CountMatchingVulnsForRules_Call

+ func (_c *VEXRuleService_CountMatchingVulnsForRules_Call) Run(run func(tx shared.DB, rules []models.VEXRule)) *VEXRuleService_CountMatchingVulnsForRules_Call

+ func (_c *VEXRuleService_CountMatchingVulnsForRules_Call) RunAndReturn(run func(tx shared.DB, rules []models.VEXRule) (map[string]int, error)) *VEXRuleService_CountMatchingVulnsForRules_Call

+ type VEXRuleService_CountMatchingVulns_Call struct

+ func (_c *VEXRuleService_CountMatchingVulns_Call) Return(n int, err error) *VEXRuleService_CountMatchingVulns_Call

+ func (_c *VEXRuleService_CountMatchingVulns_Call) Run(run func(tx shared.DB, rule models.VEXRule)) *VEXRuleService_CountMatchingVulns_Call

+ func (_c *VEXRuleService_CountMatchingVulns_Call) RunAndReturn(run func(tx shared.DB, rule models.VEXRule) (int, error)) *VEXRuleService_CountMatchingVulns_Call

+ type VEXRuleService_Create_Call struct

+ func (_c *VEXRuleService_Create_Call) Return(err error) *VEXRuleService_Create_Call

+ func (_c *VEXRuleService_Create_Call) Run(run func(tx shared.DB, rule *models.VEXRule)) *VEXRuleService_Create_Call

+ func (_c *VEXRuleService_Create_Call) RunAndReturn(run func(tx shared.DB, rule *models.VEXRule) error) *VEXRuleService_Create_Call

+ type VEXRuleService_DeleteByAssetVersion_Call struct

+ func (_c *VEXRuleService_DeleteByAssetVersion_Call) Return(err error) *VEXRuleService_DeleteByAssetVersion_Call

+ func (_c *VEXRuleService_DeleteByAssetVersion_Call) Run(run func(tx shared.DB, assetID uuid.UUID, assetVersionName string)) *VEXRuleService_DeleteByAssetVersion_Call

+ func (_c *VEXRuleService_DeleteByAssetVersion_Call) RunAndReturn(run func(tx shared.DB, assetID uuid.UUID, assetVersionName string) error) *VEXRuleService_DeleteByAssetVersion_Call

+ type VEXRuleService_Delete_Call struct

+ func (_c *VEXRuleService_Delete_Call) Return(err error) *VEXRuleService_Delete_Call

+ func (_c *VEXRuleService_Delete_Call) Run(run func(tx shared.DB, rule models.VEXRule)) *VEXRuleService_Delete_Call

+ func (_c *VEXRuleService_Delete_Call) RunAndReturn(run func(tx shared.DB, rule models.VEXRule) error) *VEXRuleService_Delete_Call

+ type VEXRuleService_Expecter struct

+ func (_e *VEXRuleService_Expecter) ApplyRulesToExisting(tx interface{}, rules interface{}, vulns interface{}) *VEXRuleService_ApplyRulesToExisting_Call

+ func (_e *VEXRuleService_Expecter) ApplyRulesToExistingForce(tx interface{}, rules interface{}, vulns interface{}) *VEXRuleService_ApplyRulesToExistingForce_Call

+ func (_e *VEXRuleService_Expecter) ApplyRulesToExistingVulns(tx interface{}, rules interface{}) *VEXRuleService_ApplyRulesToExistingVulns_Call

+ func (_e *VEXRuleService_Expecter) ApplyRulesToExistingVulnsForce(tx interface{}, rules interface{}) *VEXRuleService_ApplyRulesToExistingVulnsForce_Call

+ func (_e *VEXRuleService_Expecter) Begin() *VEXRuleService_Begin_Call

+ func (_e *VEXRuleService_Expecter) CountMatchingVulns(tx interface{}, rule interface{}) *VEXRuleService_CountMatchingVulns_Call

+ func (_e *VEXRuleService_Expecter) CountMatchingVulnsForRules(tx interface{}, rules interface{}) *VEXRuleService_CountMatchingVulnsForRules_Call

+ func (_e *VEXRuleService_Expecter) Create(tx interface{}, rule interface{}) *VEXRuleService_Create_Call

+ func (_e *VEXRuleService_Expecter) Delete(tx interface{}, rule interface{}) *VEXRuleService_Delete_Call

+ func (_e *VEXRuleService_Expecter) DeleteByAssetVersion(tx interface{}, assetID interface{}, assetVersionName interface{}) *VEXRuleService_DeleteByAssetVersion_Call

+ func (_e *VEXRuleService_Expecter) FindByAssetVersion(tx interface{}, assetID interface{}, assetVersionName interface{}) *VEXRuleService_FindByAssetVersion_Call

+ func (_e *VEXRuleService_Expecter) FindByAssetVersionAndCVE(tx interface{}, assetID interface{}, assetVersionName interface{}, ...) *VEXRuleService_FindByAssetVersionAndCVE_Call

+ func (_e *VEXRuleService_Expecter) FindByAssetVersionAndVulnID(tx interface{}, assetID interface{}, assetVersionName interface{}, ...) *VEXRuleService_FindByAssetVersionAndVulnID_Call

+ func (_e *VEXRuleService_Expecter) FindByAssetVersionPaged(tx interface{}, assetID interface{}, assetVersionName interface{}, ...) *VEXRuleService_FindByAssetVersionPaged_Call

+ func (_e *VEXRuleService_Expecter) FindByID(tx interface{}, id interface{}) *VEXRuleService_FindByID_Call

+ func (_e *VEXRuleService_Expecter) IngestVEX(tx interface{}, asset interface{}, assetVersion interface{}, ...) *VEXRuleService_IngestVEX_Call

+ func (_e *VEXRuleService_Expecter) IngestVexes(tx interface{}, asset interface{}, assetVersion interface{}, ...) *VEXRuleService_IngestVexes_Call

+ func (_e *VEXRuleService_Expecter) Update(tx interface{}, rule interface{}) *VEXRuleService_Update_Call

+ type VEXRuleService_FindByAssetVersionAndCVE_Call struct

+ func (_c *VEXRuleService_FindByAssetVersionAndCVE_Call) Return(vEXRules []models.VEXRule, err error) *VEXRuleService_FindByAssetVersionAndCVE_Call

+ func (_c *VEXRuleService_FindByAssetVersionAndCVE_Call) Run(...) *VEXRuleService_FindByAssetVersionAndCVE_Call

+ func (_c *VEXRuleService_FindByAssetVersionAndCVE_Call) RunAndReturn(...) *VEXRuleService_FindByAssetVersionAndCVE_Call

+ type VEXRuleService_FindByAssetVersionAndVulnID_Call struct

+ func (_c *VEXRuleService_FindByAssetVersionAndVulnID_Call) Return(vEXRules []models.VEXRule, err error) *VEXRuleService_FindByAssetVersionAndVulnID_Call

+ func (_c *VEXRuleService_FindByAssetVersionAndVulnID_Call) Run(...) *VEXRuleService_FindByAssetVersionAndVulnID_Call

+ func (_c *VEXRuleService_FindByAssetVersionAndVulnID_Call) RunAndReturn(...) *VEXRuleService_FindByAssetVersionAndVulnID_Call

+ type VEXRuleService_FindByAssetVersionPaged_Call struct

+ func (_c *VEXRuleService_FindByAssetVersionPaged_Call) Return(paged shared.Paged[models.VEXRule], err error) *VEXRuleService_FindByAssetVersionPaged_Call

+ func (_c *VEXRuleService_FindByAssetVersionPaged_Call) Run(run func(tx shared.DB, assetID uuid.UUID, assetVersionName string, ...)) *VEXRuleService_FindByAssetVersionPaged_Call

+ func (_c *VEXRuleService_FindByAssetVersionPaged_Call) RunAndReturn(...) *VEXRuleService_FindByAssetVersionPaged_Call

+ type VEXRuleService_FindByAssetVersion_Call struct

+ func (_c *VEXRuleService_FindByAssetVersion_Call) Return(vEXRules []models.VEXRule, err error) *VEXRuleService_FindByAssetVersion_Call

+ func (_c *VEXRuleService_FindByAssetVersion_Call) Run(run func(tx shared.DB, assetID uuid.UUID, assetVersionName string)) *VEXRuleService_FindByAssetVersion_Call

+ func (_c *VEXRuleService_FindByAssetVersion_Call) RunAndReturn(...) *VEXRuleService_FindByAssetVersion_Call

+ type VEXRuleService_FindByID_Call struct

+ func (_c *VEXRuleService_FindByID_Call) Return(vEXRule models.VEXRule, err error) *VEXRuleService_FindByID_Call

+ func (_c *VEXRuleService_FindByID_Call) Run(run func(tx shared.DB, id string)) *VEXRuleService_FindByID_Call

+ func (_c *VEXRuleService_FindByID_Call) RunAndReturn(run func(tx shared.DB, id string) (models.VEXRule, error)) *VEXRuleService_FindByID_Call

+ type VEXRuleService_IngestVEX_Call struct

+ func (_c *VEXRuleService_IngestVEX_Call) Return(err error) *VEXRuleService_IngestVEX_Call

+ func (_c *VEXRuleService_IngestVEX_Call) Run(...) *VEXRuleService_IngestVEX_Call

+ func (_c *VEXRuleService_IngestVEX_Call) RunAndReturn(...) *VEXRuleService_IngestVEX_Call

+ type VEXRuleService_IngestVexes_Call struct

+ func (_c *VEXRuleService_IngestVexes_Call) Return(err error) *VEXRuleService_IngestVexes_Call

+ func (_c *VEXRuleService_IngestVexes_Call) Run(...) *VEXRuleService_IngestVexes_Call

+ func (_c *VEXRuleService_IngestVexes_Call) RunAndReturn(...) *VEXRuleService_IngestVexes_Call

+ type VEXRuleService_Update_Call struct

+ func (_c *VEXRuleService_Update_Call) Return(err error) *VEXRuleService_Update_Call

+ func (_c *VEXRuleService_Update_Call) Run(run func(tx shared.DB, rule *models.VEXRule)) *VEXRuleService_Update_Call

+ func (_c *VEXRuleService_Update_Call) RunAndReturn(run func(tx shared.DB, rule *models.VEXRule) error) *VEXRuleService_Update_Call

+ type Vuln struct

+ func NewVuln(t interface{ ... }) *Vuln

+ func (_m *Vuln) EXPECT() *Vuln_Expecter

+ func (_mock *Vuln) AddScannerID(scannerID string)

+ func (_mock *Vuln) AssetVersionIndependentHash() string

+ func (_mock *Vuln) CalculateHash() string

+ func (_mock *Vuln) GetArtifacts() []models.Artifact

+ func (_mock *Vuln) GetAssetID() uuid.UUID

+ func (_mock *Vuln) GetAssetVersionName() string

+ func (_mock *Vuln) GetEvents() []models.VulnEvent

+ func (_mock *Vuln) GetID() string

+ func (_mock *Vuln) GetManualTicketCreation() bool

+ func (_mock *Vuln) GetRawRiskAssessment() float64

+ func (_mock *Vuln) GetScannerIDsOrArtifactNames() string

+ func (_mock *Vuln) GetState() dtos.VulnState

+ func (_mock *Vuln) GetTicketID() *string

+ func (_mock *Vuln) GetTicketURL() *string

+ func (_mock *Vuln) GetType() dtos.VulnType

+ func (_mock *Vuln) RemoveScannerID(scannerID string)

+ func (_mock *Vuln) SetManualTicketCreation(manualTicketCreation bool)

+ func (_mock *Vuln) SetRawRiskAssessment(risk float64)

+ func (_mock *Vuln) SetRiskRecalculatedAt(time1 time.Time)

+ func (_mock *Vuln) SetState(state dtos.VulnState)

+ func (_mock *Vuln) SetTicketID(ticketID string)

+ func (_mock *Vuln) SetTicketURL(ticketURL string)

+ func (_mock *Vuln) TableName() string

+ type VulnDBImportService struct

+ func NewVulnDBImportService(t interface{ ... }) *VulnDBImportService

+ func (_m *VulnDBImportService) EXPECT() *VulnDBImportService_Expecter

+ func (_mock *VulnDBImportService) CleanupOrphanedTables() error

+ func (_mock *VulnDBImportService) CreateTablesWithSuffix(suffix string) error

+ func (_mock *VulnDBImportService) ExportDiffs(extraTableNameSuffix string) error

+ func (_mock *VulnDBImportService) ImportFromDiff(extraTableNameSuffix *string) error

+ type VulnDBImportService_CleanupOrphanedTables_Call struct

+ func (_c *VulnDBImportService_CleanupOrphanedTables_Call) Return(err error) *VulnDBImportService_CleanupOrphanedTables_Call

+ func (_c *VulnDBImportService_CleanupOrphanedTables_Call) Run(run func()) *VulnDBImportService_CleanupOrphanedTables_Call

+ func (_c *VulnDBImportService_CleanupOrphanedTables_Call) RunAndReturn(run func() error) *VulnDBImportService_CleanupOrphanedTables_Call

+ type VulnDBImportService_CreateTablesWithSuffix_Call struct

+ func (_c *VulnDBImportService_CreateTablesWithSuffix_Call) Return(err error) *VulnDBImportService_CreateTablesWithSuffix_Call

+ func (_c *VulnDBImportService_CreateTablesWithSuffix_Call) Run(run func(suffix string)) *VulnDBImportService_CreateTablesWithSuffix_Call

+ func (_c *VulnDBImportService_CreateTablesWithSuffix_Call) RunAndReturn(run func(suffix string) error) *VulnDBImportService_CreateTablesWithSuffix_Call

+ type VulnDBImportService_Expecter struct

+ func (_e *VulnDBImportService_Expecter) CleanupOrphanedTables() *VulnDBImportService_CleanupOrphanedTables_Call

+ func (_e *VulnDBImportService_Expecter) CreateTablesWithSuffix(suffix interface{}) *VulnDBImportService_CreateTablesWithSuffix_Call

+ func (_e *VulnDBImportService_Expecter) ExportDiffs(extraTableNameSuffix interface{}) *VulnDBImportService_ExportDiffs_Call

+ func (_e *VulnDBImportService_Expecter) ImportFromDiff(extraTableNameSuffix interface{}) *VulnDBImportService_ImportFromDiff_Call

+ type VulnDBImportService_ExportDiffs_Call struct

+ func (_c *VulnDBImportService_ExportDiffs_Call) Return(err error) *VulnDBImportService_ExportDiffs_Call

+ func (_c *VulnDBImportService_ExportDiffs_Call) Run(run func(extraTableNameSuffix string)) *VulnDBImportService_ExportDiffs_Call

+ func (_c *VulnDBImportService_ExportDiffs_Call) RunAndReturn(run func(extraTableNameSuffix string) error) *VulnDBImportService_ExportDiffs_Call

+ type VulnDBImportService_ImportFromDiff_Call struct

+ func (_c *VulnDBImportService_ImportFromDiff_Call) Return(err error) *VulnDBImportService_ImportFromDiff_Call

+ func (_c *VulnDBImportService_ImportFromDiff_Call) Run(run func(extraTableNameSuffix *string)) *VulnDBImportService_ImportFromDiff_Call

+ func (_c *VulnDBImportService_ImportFromDiff_Call) RunAndReturn(run func(extraTableNameSuffix *string) error) *VulnDBImportService_ImportFromDiff_Call

type VulnEventRepository

+ func (_mock *VulnEventRepository) DeleteEventByID(tx shared.DB, eventID string) error

+ func (_mock *VulnEventRepository) GetLastEventBeforeTimestamp(tx shared.DB, vulnID string, time1 time.Time) (models.VulnEvent, error)

+ func (_mock *VulnEventRepository) GetSecurityRelevantEventsForVulnIDs(tx shared.DB, vulnIDs []string) ([]models.VulnEvent, error)

+ func (_mock *VulnEventRepository) HasAccessToEvent(assetID uuid.UUID, eventID string) (bool, error)

+ func (_mock *VulnEventRepository) SaveBatchBestEffort(db shared.DB, events []models.VulnEvent) error

+ type VulnEventRepository_DeleteEventByID_Call struct

+ func (_c *VulnEventRepository_DeleteEventByID_Call) Return(err error) *VulnEventRepository_DeleteEventByID_Call

+ func (_c *VulnEventRepository_DeleteEventByID_Call) Run(run func(tx shared.DB, eventID string)) *VulnEventRepository_DeleteEventByID_Call

+ func (_c *VulnEventRepository_DeleteEventByID_Call) RunAndReturn(run func(tx shared.DB, eventID string) error) *VulnEventRepository_DeleteEventByID_Call

type VulnEventRepository_Expecter

+ func (_e *VulnEventRepository_Expecter) DeleteEventByID(tx interface{}, eventID interface{}) *VulnEventRepository_DeleteEventByID_Call

+ func (_e *VulnEventRepository_Expecter) GetLastEventBeforeTimestamp(tx interface{}, vulnID interface{}, time1 interface{}) *VulnEventRepository_GetLastEventBeforeTimestamp_Call

+ func (_e *VulnEventRepository_Expecter) GetSecurityRelevantEventsForVulnIDs(tx interface{}, vulnIDs interface{}) *VulnEventRepository_GetSecurityRelevantEventsForVulnIDs_Call

+ func (_e *VulnEventRepository_Expecter) HasAccessToEvent(assetID interface{}, eventID interface{}) *VulnEventRepository_HasAccessToEvent_Call

+ func (_e *VulnEventRepository_Expecter) SaveBatchBestEffort(db interface{}, events interface{}) *VulnEventRepository_SaveBatchBestEffort_Call

+ type VulnEventRepository_GetLastEventBeforeTimestamp_Call struct

+ func (_c *VulnEventRepository_GetLastEventBeforeTimestamp_Call) Return(vulnEvent models.VulnEvent, err error) *VulnEventRepository_GetLastEventBeforeTimestamp_Call

+ func (_c *VulnEventRepository_GetLastEventBeforeTimestamp_Call) Run(run func(tx shared.DB, vulnID string, time1 time.Time)) *VulnEventRepository_GetLastEventBeforeTimestamp_Call

+ func (_c *VulnEventRepository_GetLastEventBeforeTimestamp_Call) RunAndReturn(...) *VulnEventRepository_GetLastEventBeforeTimestamp_Call

+ type VulnEventRepository_GetSecurityRelevantEventsForVulnIDs_Call struct

+ func (_c *VulnEventRepository_GetSecurityRelevantEventsForVulnIDs_Call) Return(vulnEvents []models.VulnEvent, err error) *VulnEventRepository_GetSecurityRelevantEventsForVulnIDs_Call

+ func (_c *VulnEventRepository_GetSecurityRelevantEventsForVulnIDs_Call) Run(run func(tx shared.DB, vulnIDs []string)) *VulnEventRepository_GetSecurityRelevantEventsForVulnIDs_Call

+ func (_c *VulnEventRepository_GetSecurityRelevantEventsForVulnIDs_Call) RunAndReturn(run func(tx shared.DB, vulnIDs []string) ([]models.VulnEvent, error)) *VulnEventRepository_GetSecurityRelevantEventsForVulnIDs_Call

+ type VulnEventRepository_HasAccessToEvent_Call struct

+ func (_c *VulnEventRepository_HasAccessToEvent_Call) Return(b bool, err error) *VulnEventRepository_HasAccessToEvent_Call

+ func (_c *VulnEventRepository_HasAccessToEvent_Call) Run(run func(assetID uuid.UUID, eventID string)) *VulnEventRepository_HasAccessToEvent_Call

+ func (_c *VulnEventRepository_HasAccessToEvent_Call) RunAndReturn(run func(assetID uuid.UUID, eventID string) (bool, error)) *VulnEventRepository_HasAccessToEvent_Call

+ type VulnEventRepository_SaveBatchBestEffort_Call struct

+ func (_c *VulnEventRepository_SaveBatchBestEffort_Call) Return(err error) *VulnEventRepository_SaveBatchBestEffort_Call

+ func (_c *VulnEventRepository_SaveBatchBestEffort_Call) Run(run func(db shared.DB, events []models.VulnEvent)) *VulnEventRepository_SaveBatchBestEffort_Call

+ func (_c *VulnEventRepository_SaveBatchBestEffort_Call) RunAndReturn(run func(db shared.DB, events []models.VulnEvent) error) *VulnEventRepository_SaveBatchBestEffort_Call

+ type Vuln_AddScannerID_Call struct

+ func (_c *Vuln_AddScannerID_Call) Return() *Vuln_AddScannerID_Call

+ func (_c *Vuln_AddScannerID_Call) Run(run func(scannerID string)) *Vuln_AddScannerID_Call

+ func (_c *Vuln_AddScannerID_Call) RunAndReturn(run func(scannerID string)) *Vuln_AddScannerID_Call

+ type Vuln_AssetVersionIndependentHash_Call struct

+ func (_c *Vuln_AssetVersionIndependentHash_Call) Return(s string) *Vuln_AssetVersionIndependentHash_Call

+ func (_c *Vuln_AssetVersionIndependentHash_Call) Run(run func()) *Vuln_AssetVersionIndependentHash_Call

+ func (_c *Vuln_AssetVersionIndependentHash_Call) RunAndReturn(run func() string) *Vuln_AssetVersionIndependentHash_Call

+ type Vuln_CalculateHash_Call struct

+ func (_c *Vuln_CalculateHash_Call) Return(s string) *Vuln_CalculateHash_Call

+ func (_c *Vuln_CalculateHash_Call) Run(run func()) *Vuln_CalculateHash_Call

+ func (_c *Vuln_CalculateHash_Call) RunAndReturn(run func() string) *Vuln_CalculateHash_Call

+ type Vuln_Expecter struct

+ func (_e *Vuln_Expecter) AddScannerID(scannerID interface{}) *Vuln_AddScannerID_Call

+ func (_e *Vuln_Expecter) AssetVersionIndependentHash() *Vuln_AssetVersionIndependentHash_Call

+ func (_e *Vuln_Expecter) CalculateHash() *Vuln_CalculateHash_Call

+ func (_e *Vuln_Expecter) GetArtifacts() *Vuln_GetArtifacts_Call

+ func (_e *Vuln_Expecter) GetAssetID() *Vuln_GetAssetID_Call

+ func (_e *Vuln_Expecter) GetAssetVersionName() *Vuln_GetAssetVersionName_Call

+ func (_e *Vuln_Expecter) GetEvents() *Vuln_GetEvents_Call

+ func (_e *Vuln_Expecter) GetID() *Vuln_GetID_Call

+ func (_e *Vuln_Expecter) GetManualTicketCreation() *Vuln_GetManualTicketCreation_Call

+ func (_e *Vuln_Expecter) GetRawRiskAssessment() *Vuln_GetRawRiskAssessment_Call

+ func (_e *Vuln_Expecter) GetScannerIDsOrArtifactNames() *Vuln_GetScannerIDsOrArtifactNames_Call

+ func (_e *Vuln_Expecter) GetState() *Vuln_GetState_Call

+ func (_e *Vuln_Expecter) GetTicketID() *Vuln_GetTicketID_Call

+ func (_e *Vuln_Expecter) GetTicketURL() *Vuln_GetTicketURL_Call

+ func (_e *Vuln_Expecter) GetType() *Vuln_GetType_Call

+ func (_e *Vuln_Expecter) RemoveScannerID(scannerID interface{}) *Vuln_RemoveScannerID_Call

+ func (_e *Vuln_Expecter) SetManualTicketCreation(manualTicketCreation interface{}) *Vuln_SetManualTicketCreation_Call

+ func (_e *Vuln_Expecter) SetRawRiskAssessment(risk interface{}) *Vuln_SetRawRiskAssessment_Call

+ func (_e *Vuln_Expecter) SetRiskRecalculatedAt(time1 interface{}) *Vuln_SetRiskRecalculatedAt_Call

+ func (_e *Vuln_Expecter) SetState(state interface{}) *Vuln_SetState_Call

+ func (_e *Vuln_Expecter) SetTicketID(ticketID interface{}) *Vuln_SetTicketID_Call

+ func (_e *Vuln_Expecter) SetTicketURL(ticketURL interface{}) *Vuln_SetTicketURL_Call

+ func (_e *Vuln_Expecter) TableName() *Vuln_TableName_Call

+ type Vuln_GetArtifacts_Call struct

+ func (_c *Vuln_GetArtifacts_Call) Return(artifacts []models.Artifact) *Vuln_GetArtifacts_Call

+ func (_c *Vuln_GetArtifacts_Call) Run(run func()) *Vuln_GetArtifacts_Call

+ func (_c *Vuln_GetArtifacts_Call) RunAndReturn(run func() []models.Artifact) *Vuln_GetArtifacts_Call

+ type Vuln_GetAssetID_Call struct

+ func (_c *Vuln_GetAssetID_Call) Return(uUID uuid.UUID) *Vuln_GetAssetID_Call

+ func (_c *Vuln_GetAssetID_Call) Run(run func()) *Vuln_GetAssetID_Call

+ func (_c *Vuln_GetAssetID_Call) RunAndReturn(run func() uuid.UUID) *Vuln_GetAssetID_Call

+ type Vuln_GetAssetVersionName_Call struct

+ func (_c *Vuln_GetAssetVersionName_Call) Return(s string) *Vuln_GetAssetVersionName_Call

+ func (_c *Vuln_GetAssetVersionName_Call) Run(run func()) *Vuln_GetAssetVersionName_Call

+ func (_c *Vuln_GetAssetVersionName_Call) RunAndReturn(run func() string) *Vuln_GetAssetVersionName_Call

+ type Vuln_GetEvents_Call struct

+ func (_c *Vuln_GetEvents_Call) Return(vulnEvents []models.VulnEvent) *Vuln_GetEvents_Call

+ func (_c *Vuln_GetEvents_Call) Run(run func()) *Vuln_GetEvents_Call

+ func (_c *Vuln_GetEvents_Call) RunAndReturn(run func() []models.VulnEvent) *Vuln_GetEvents_Call

+ type Vuln_GetID_Call struct

+ func (_c *Vuln_GetID_Call) Return(s string) *Vuln_GetID_Call

+ func (_c *Vuln_GetID_Call) Run(run func()) *Vuln_GetID_Call

+ func (_c *Vuln_GetID_Call) RunAndReturn(run func() string) *Vuln_GetID_Call

+ type Vuln_GetManualTicketCreation_Call struct

+ func (_c *Vuln_GetManualTicketCreation_Call) Return(b bool) *Vuln_GetManualTicketCreation_Call

+ func (_c *Vuln_GetManualTicketCreation_Call) Run(run func()) *Vuln_GetManualTicketCreation_Call

+ func (_c *Vuln_GetManualTicketCreation_Call) RunAndReturn(run func() bool) *Vuln_GetManualTicketCreation_Call

+ type Vuln_GetRawRiskAssessment_Call struct

+ func (_c *Vuln_GetRawRiskAssessment_Call) Return(f float64) *Vuln_GetRawRiskAssessment_Call

+ func (_c *Vuln_GetRawRiskAssessment_Call) Run(run func()) *Vuln_GetRawRiskAssessment_Call

+ func (_c *Vuln_GetRawRiskAssessment_Call) RunAndReturn(run func() float64) *Vuln_GetRawRiskAssessment_Call

+ type Vuln_GetScannerIDsOrArtifactNames_Call struct

+ func (_c *Vuln_GetScannerIDsOrArtifactNames_Call) Return(s string) *Vuln_GetScannerIDsOrArtifactNames_Call

+ func (_c *Vuln_GetScannerIDsOrArtifactNames_Call) Run(run func()) *Vuln_GetScannerIDsOrArtifactNames_Call

+ func (_c *Vuln_GetScannerIDsOrArtifactNames_Call) RunAndReturn(run func() string) *Vuln_GetScannerIDsOrArtifactNames_Call

+ type Vuln_GetState_Call struct

+ func (_c *Vuln_GetState_Call) Return(vulnState dtos.VulnState) *Vuln_GetState_Call

+ func (_c *Vuln_GetState_Call) Run(run func()) *Vuln_GetState_Call

+ func (_c *Vuln_GetState_Call) RunAndReturn(run func() dtos.VulnState) *Vuln_GetState_Call

+ type Vuln_GetTicketID_Call struct

+ func (_c *Vuln_GetTicketID_Call) Return(s *string) *Vuln_GetTicketID_Call

+ func (_c *Vuln_GetTicketID_Call) Run(run func()) *Vuln_GetTicketID_Call

+ func (_c *Vuln_GetTicketID_Call) RunAndReturn(run func() *string) *Vuln_GetTicketID_Call

+ type Vuln_GetTicketURL_Call struct

+ func (_c *Vuln_GetTicketURL_Call) Return(s *string) *Vuln_GetTicketURL_Call

+ func (_c *Vuln_GetTicketURL_Call) Run(run func()) *Vuln_GetTicketURL_Call

+ func (_c *Vuln_GetTicketURL_Call) RunAndReturn(run func() *string) *Vuln_GetTicketURL_Call

+ type Vuln_GetType_Call struct

+ func (_c *Vuln_GetType_Call) Return(vulnType dtos.VulnType) *Vuln_GetType_Call

+ func (_c *Vuln_GetType_Call) Run(run func()) *Vuln_GetType_Call

+ func (_c *Vuln_GetType_Call) RunAndReturn(run func() dtos.VulnType) *Vuln_GetType_Call

+ type Vuln_RemoveScannerID_Call struct

+ func (_c *Vuln_RemoveScannerID_Call) Return() *Vuln_RemoveScannerID_Call

+ func (_c *Vuln_RemoveScannerID_Call) Run(run func(scannerID string)) *Vuln_RemoveScannerID_Call

+ func (_c *Vuln_RemoveScannerID_Call) RunAndReturn(run func(scannerID string)) *Vuln_RemoveScannerID_Call

+ type Vuln_SetManualTicketCreation_Call struct

+ func (_c *Vuln_SetManualTicketCreation_Call) Return() *Vuln_SetManualTicketCreation_Call

+ func (_c *Vuln_SetManualTicketCreation_Call) Run(run func(manualTicketCreation bool)) *Vuln_SetManualTicketCreation_Call

+ func (_c *Vuln_SetManualTicketCreation_Call) RunAndReturn(run func(manualTicketCreation bool)) *Vuln_SetManualTicketCreation_Call

+ type Vuln_SetRawRiskAssessment_Call struct

+ func (_c *Vuln_SetRawRiskAssessment_Call) Return() *Vuln_SetRawRiskAssessment_Call

+ func (_c *Vuln_SetRawRiskAssessment_Call) Run(run func(risk float64)) *Vuln_SetRawRiskAssessment_Call

+ func (_c *Vuln_SetRawRiskAssessment_Call) RunAndReturn(run func(risk float64)) *Vuln_SetRawRiskAssessment_Call

+ type Vuln_SetRiskRecalculatedAt_Call struct

+ func (_c *Vuln_SetRiskRecalculatedAt_Call) Return() *Vuln_SetRiskRecalculatedAt_Call

+ func (_c *Vuln_SetRiskRecalculatedAt_Call) Run(run func(time1 time.Time)) *Vuln_SetRiskRecalculatedAt_Call

+ func (_c *Vuln_SetRiskRecalculatedAt_Call) RunAndReturn(run func(time1 time.Time)) *Vuln_SetRiskRecalculatedAt_Call

+ type Vuln_SetState_Call struct

+ func (_c *Vuln_SetState_Call) Return() *Vuln_SetState_Call

+ func (_c *Vuln_SetState_Call) Run(run func(state dtos.VulnState)) *Vuln_SetState_Call

+ func (_c *Vuln_SetState_Call) RunAndReturn(run func(state dtos.VulnState)) *Vuln_SetState_Call

+ type Vuln_SetTicketID_Call struct

+ func (_c *Vuln_SetTicketID_Call) Return() *Vuln_SetTicketID_Call

+ func (_c *Vuln_SetTicketID_Call) Run(run func(ticketID string)) *Vuln_SetTicketID_Call

+ func (_c *Vuln_SetTicketID_Call) RunAndReturn(run func(ticketID string)) *Vuln_SetTicketID_Call

+ type Vuln_SetTicketURL_Call struct

+ func (_c *Vuln_SetTicketURL_Call) Return() *Vuln_SetTicketURL_Call

+ func (_c *Vuln_SetTicketURL_Call) Run(run func(ticketURL string)) *Vuln_SetTicketURL_Call

+ func (_c *Vuln_SetTicketURL_Call) RunAndReturn(run func(ticketURL string)) *Vuln_SetTicketURL_Call

+ type Vuln_TableName_Call struct

+ func (_c *Vuln_TableName_Call) Return(s string) *Vuln_TableName_Call

+ func (_c *Vuln_TableName_Call) Run(run func()) *Vuln_TableName_Call

+ func (_c *Vuln_TableName_Call) RunAndReturn(run func() string) *Vuln_TableName_Call

v1.0.0-rc.18

Feb 17, 2026

v1.0.0-rc.17

Jan 19, 2026

v1.0.0-rc.16

Jan 13, 2026

v1.0.0-rc.15

Jan 8, 2026

v1.0.0-rc.14

Jan 4, 2026

v1.0.0-rc.13

Dec 30, 2025

v1.0.0-rc.12

Dec 23, 2025

v1.0.0-rc.11

Dec 19, 2025

v1.0.0-rc.10

Dec 15, 2025

v1.0.0-rc.9

Dec 14, 2025

v1.0.0-rc.8

Dec 14, 2025

v1.0.0-rc.7

Dec 14, 2025

v1.0.0-rc.6

Dec 12, 2025

v1.0.0-rc.5

Dec 9, 2025

v1.0.0-rc.4

Dec 4, 2025

v1.0.0-rc.3

Dec 4, 2025

v1.0.0-rc.2

Nov 24, 2025

v1.0.0-rc.1

Nov 20, 2025

v0

v0.19.2

Nov 4, 2025

v0.19.1

Nov 3, 2025

v0.19.0

Nov 2, 2025

Changes in this version

type ArtifactService

+ func (_mock *ArtifactService) FetchBomsFromUpstream(artifactName string, upstreamURLs []string) ([]*normalize.CdxBom, []string, []string)

+ func (_mock *ArtifactService) ReadArtifact(name string, assetVersionName string, assetID uuid.UUID) (models.Artifact, error)

+ func (_mock *ArtifactService) SyncUpstreamBoms(boms []*normalize.CdxBom, org models.Org, project models.Project, ...) ([]models.DependencyVuln, error)

type ArtifactService_Expecter

+ func (_e *ArtifactService_Expecter) FetchBomsFromUpstream(artifactName interface{}, upstreamURLs interface{}) *ArtifactService_FetchBomsFromUpstream_Call

+ func (_e *ArtifactService_Expecter) ReadArtifact(name interface{}, assetVersionName interface{}, assetID interface{}) *ArtifactService_ReadArtifact_Call

+ func (_e *ArtifactService_Expecter) SyncUpstreamBoms(boms interface{}, org interface{}, project interface{}, asset interface{}, ...) *ArtifactService_SyncUpstreamBoms_Call

+ type ArtifactService_FetchBomsFromUpstream_Call struct

+ func (_c *ArtifactService_FetchBomsFromUpstream_Call) Return(cdxBoms []*normalize.CdxBom, strings []string, strings1 []string) *ArtifactService_FetchBomsFromUpstream_Call

+ func (_c *ArtifactService_FetchBomsFromUpstream_Call) Run(run func(artifactName string, upstreamURLs []string)) *ArtifactService_FetchBomsFromUpstream_Call

+ func (_c *ArtifactService_FetchBomsFromUpstream_Call) RunAndReturn(...) *ArtifactService_FetchBomsFromUpstream_Call

+ type ArtifactService_ReadArtifact_Call struct

+ func (_c *ArtifactService_ReadArtifact_Call) Return(artifact models.Artifact, err error) *ArtifactService_ReadArtifact_Call

+ func (_c *ArtifactService_ReadArtifact_Call) Run(run func(name string, assetVersionName string, assetID uuid.UUID)) *ArtifactService_ReadArtifact_Call

+ func (_c *ArtifactService_ReadArtifact_Call) RunAndReturn(...) *ArtifactService_ReadArtifact_Call

+ type ArtifactService_SyncUpstreamBoms_Call struct

+ func (_c *ArtifactService_SyncUpstreamBoms_Call) Return(dependencyVulns []models.DependencyVuln, err error) *ArtifactService_SyncUpstreamBoms_Call

+ func (_c *ArtifactService_SyncUpstreamBoms_Call) Run(...) *ArtifactService_SyncUpstreamBoms_Call

+ func (_c *ArtifactService_SyncUpstreamBoms_Call) RunAndReturn(...) *ArtifactService_SyncUpstreamBoms_Call

type AssetVersionRepository

+ func (_mock *AssetVersionRepository) UpdateAssetDefaultBranch(assetID uuid.UUID, defaultBranch string) error

type AssetVersionRepository_Expecter

+ func (_e *AssetVersionRepository_Expecter) UpdateAssetDefaultBranch(assetID interface{}, defaultBranch interface{}) *AssetVersionRepository_UpdateAssetDefaultBranch_Call

+ type AssetVersionRepository_UpdateAssetDefaultBranch_Call struct

+ func (_c *AssetVersionRepository_UpdateAssetDefaultBranch_Call) Return(err error) *AssetVersionRepository_UpdateAssetDefaultBranch_Call

+ func (_c *AssetVersionRepository_UpdateAssetDefaultBranch_Call) Run(run func(assetID uuid.UUID, defaultBranch string)) *AssetVersionRepository_UpdateAssetDefaultBranch_Call

+ func (_c *AssetVersionRepository_UpdateAssetDefaultBranch_Call) RunAndReturn(run func(assetID uuid.UUID, defaultBranch string) error) *AssetVersionRepository_UpdateAssetDefaultBranch_Call

type ComponentRepository

+ func (_mock *ComponentRepository) CreateComponents(tx core.DB, components []models.ComponentDependency) error

+ func (_mock *ComponentRepository) FetchInformationSources(artifact *models.Artifact) ([]models.ComponentDependency, error)

+ func (_mock *ComponentRepository) RemoveInformationSources(artifact *models.Artifact, rootNodePurls []string) error

+ type ComponentRepository_CreateComponents_Call struct

+ func (_c *ComponentRepository_CreateComponents_Call) Return(err error) *ComponentRepository_CreateComponents_Call

+ func (_c *ComponentRepository_CreateComponents_Call) Run(run func(tx core.DB, components []models.ComponentDependency)) *ComponentRepository_CreateComponents_Call

+ func (_c *ComponentRepository_CreateComponents_Call) RunAndReturn(run func(tx core.DB, components []models.ComponentDependency) error) *ComponentRepository_CreateComponents_Call

type ComponentRepository_Expecter

+ func (_e *ComponentRepository_Expecter) CreateComponents(tx interface{}, components interface{}) *ComponentRepository_CreateComponents_Call

+ func (_e *ComponentRepository_Expecter) FetchInformationSources(artifact interface{}) *ComponentRepository_FetchInformationSources_Call

+ func (_e *ComponentRepository_Expecter) RemoveInformationSources(artifact interface{}, rootNodePurls interface{}) *ComponentRepository_RemoveInformationSources_Call

+ type ComponentRepository_FetchInformationSources_Call struct

+ func (_c *ComponentRepository_FetchInformationSources_Call) Return(componentDependencys []models.ComponentDependency, err error) *ComponentRepository_FetchInformationSources_Call

+ func (_c *ComponentRepository_FetchInformationSources_Call) Run(run func(artifact *models.Artifact)) *ComponentRepository_FetchInformationSources_Call

+ func (_c *ComponentRepository_FetchInformationSources_Call) RunAndReturn(run func(artifact *models.Artifact) ([]models.ComponentDependency, error)) *ComponentRepository_FetchInformationSources_Call

+ type ComponentRepository_RemoveInformationSources_Call struct

+ func (_c *ComponentRepository_RemoveInformationSources_Call) Return(err error) *ComponentRepository_RemoveInformationSources_Call

+ func (_c *ComponentRepository_RemoveInformationSources_Call) Run(run func(artifact *models.Artifact, rootNodePurls []string)) *ComponentRepository_RemoveInformationSources_Call

+ func (_c *ComponentRepository_RemoveInformationSources_Call) RunAndReturn(run func(artifact *models.Artifact, rootNodePurls []string) error) *ComponentRepository_RemoveInformationSources_Call

type ComponentService

+ func (_mock *ComponentService) FetchInformationSources(artifact *models.Artifact) ([]models.ComponentDependency, error)

+ func (_mock *ComponentService) RemoveInformationSources(artifact *models.Artifact, rootNodePurls []string) error

type ComponentService_Expecter

+ func (_e *ComponentService_Expecter) FetchInformationSources(artifact interface{}) *ComponentService_FetchInformationSources_Call

+ func (_e *ComponentService_Expecter) RemoveInformationSources(artifact interface{}, rootNodePurls interface{}) *ComponentService_RemoveInformationSources_Call

+ type ComponentService_FetchInformationSources_Call struct

+ func (_c *ComponentService_FetchInformationSources_Call) Return(componentDependencys []models.ComponentDependency, err error) *ComponentService_FetchInformationSources_Call

+ func (_c *ComponentService_FetchInformationSources_Call) Run(run func(artifact *models.Artifact)) *ComponentService_FetchInformationSources_Call

+ func (_c *ComponentService_FetchInformationSources_Call) RunAndReturn(run func(artifact *models.Artifact) ([]models.ComponentDependency, error)) *ComponentService_FetchInformationSources_Call

+ type ComponentService_RemoveInformationSources_Call struct

+ func (_c *ComponentService_RemoveInformationSources_Call) Return(err error) *ComponentService_RemoveInformationSources_Call

+ func (_c *ComponentService_RemoveInformationSources_Call) Run(run func(artifact *models.Artifact, rootNodePurls []string)) *ComponentService_RemoveInformationSources_Call

+ func (_c *ComponentService_RemoveInformationSources_Call) RunAndReturn(run func(artifact *models.Artifact, rootNodePurls []string) error) *ComponentService_RemoveInformationSources_Call

+ type DependencyTree struct

+ func NewDependencyTree(t interface{ ... }) *DependencyTree

+ func (_m *DependencyTree) EXPECT() *DependencyTree_Expecter

+ func (_mock *DependencyTree) GetDeps() []string

+ func (_mock *DependencyTree) GetRef() string

+ type DependencyTree_Expecter struct

+ func (_e *DependencyTree_Expecter) GetDeps() *DependencyTree_GetDeps_Call

+ func (_e *DependencyTree_Expecter) GetRef() *DependencyTree_GetRef_Call

+ type DependencyTree_GetDeps_Call struct

+ func (_c *DependencyTree_GetDeps_Call) Return(strings []string) *DependencyTree_GetDeps_Call

+ func (_c *DependencyTree_GetDeps_Call) Run(run func()) *DependencyTree_GetDeps_Call

+ func (_c *DependencyTree_GetDeps_Call) RunAndReturn(run func() []string) *DependencyTree_GetDeps_Call

+ type DependencyTree_GetRef_Call struct

+ func (_c *DependencyTree_GetRef_Call) Return(s string) *DependencyTree_GetRef_Call

+ func (_c *DependencyTree_GetRef_Call) Run(run func()) *DependencyTree_GetRef_Call

+ func (_c *DependencyTree_GetRef_Call) RunAndReturn(run func() string) *DependencyTree_GetRef_Call

type DependencyVulnRepository

+ func (_mock *DependencyVulnRepository) ListByAssetIDWithoutHandledExternalEvents(assetID uuid.UUID, assetVersionName string, pageInfo core.PageInfo, ...) (core.Paged[models.DependencyVuln], error)

type DependencyVulnRepository_Expecter

+ func (_e *DependencyVulnRepository_Expecter) ListByAssetIDWithoutHandledExternalEvents(assetID interface{}, assetVersionName interface{}, pageInfo interface{}, ...) *DependencyVulnRepository_ListByAssetIDWithoutHandledExternalEvents_Call

+ type DependencyVulnRepository_ListByAssetIDWithoutHandledExternalEvents_Call struct

+ func (_c *DependencyVulnRepository_ListByAssetIDWithoutHandledExternalEvents_Call) Return(paged core.Paged[models.DependencyVuln], err error) *DependencyVulnRepository_ListByAssetIDWithoutHandledExternalEvents_Call

+ func (_c *DependencyVulnRepository_ListByAssetIDWithoutHandledExternalEvents_Call) Run(...) *DependencyVulnRepository_ListByAssetIDWithoutHandledExternalEvents_Call

+ func (_c *DependencyVulnRepository_ListByAssetIDWithoutHandledExternalEvents_Call) RunAndReturn(...) *DependencyVulnRepository_ListByAssetIDWithoutHandledExternalEvents_Call

type DependencyVulnService

+ func (_mock *DependencyVulnService) CreateVulnEventAndApply(tx core.DB, assetID uuid.UUID, userID string, ...) (models.VulnEvent, error)

+ type DependencyVulnService_CreateVulnEventAndApply_Call struct

+ func (_c *DependencyVulnService_CreateVulnEventAndApply_Call) Return(vulnEvent models.VulnEvent, err error) *DependencyVulnService_CreateVulnEventAndApply_Call

+ func (_c *DependencyVulnService_CreateVulnEventAndApply_Call) Run(run func(tx core.DB, assetID uuid.UUID, userID string, ...)) *DependencyVulnService_CreateVulnEventAndApply_Call

+ func (_c *DependencyVulnService_CreateVulnEventAndApply_Call) RunAndReturn(...) *DependencyVulnService_CreateVulnEventAndApply_Call

type DependencyVulnService_Expecter

+ func (_e *DependencyVulnService_Expecter) CreateVulnEventAndApply(tx interface{}, assetID interface{}, userID interface{}, ...) *DependencyVulnService_CreateVulnEventAndApply_Call

+ type Node struct

+ func NewNode(t interface{ ... }) *Node

+ func (_m *Node) EXPECT() *Node_Expecter

+ func (_mock *Node) GetID() string

+ type Node_Expecter struct

+ func (_e *Node_Expecter) GetID() *Node_GetID_Call

+ type Node_GetID_Call struct

+ func (_c *Node_GetID_Call) Return(s string) *Node_GetID_Call

+ func (_c *Node_GetID_Call) Run(run func()) *Node_GetID_Call

+ func (_c *Node_GetID_Call) RunAndReturn(run func() string) *Node_GetID_Call

type SBOM

+ func (_mock *SBOM) Eject() *cyclonedx.BOM

+ func (_mock *SBOM) GetOrigin() string

+ func (_mock *SBOM) GetVulnerabilities() *[]cyclonedx.Vulnerability

+ type SBOM_Eject_Call struct

+ func (_c *SBOM_Eject_Call) Return(bOM *cyclonedx.BOM) *SBOM_Eject_Call

+ func (_c *SBOM_Eject_Call) Run(run func()) *SBOM_Eject_Call

+ func (_c *SBOM_Eject_Call) RunAndReturn(run func() *cyclonedx.BOM) *SBOM_Eject_Call

type SBOM_Expecter

+ func (_e *SBOM_Expecter) Eject() *SBOM_Eject_Call

+ func (_e *SBOM_Expecter) GetOrigin() *SBOM_GetOrigin_Call

+ func (_e *SBOM_Expecter) GetVulnerabilities() *SBOM_GetVulnerabilities_Call

+ type SBOM_GetOrigin_Call struct

+ func (_c *SBOM_GetOrigin_Call) Return(s string) *SBOM_GetOrigin_Call

+ func (_c *SBOM_GetOrigin_Call) Run(run func()) *SBOM_GetOrigin_Call

+ func (_c *SBOM_GetOrigin_Call) RunAndReturn(run func() string) *SBOM_GetOrigin_Call

+ type SBOM_GetVulnerabilities_Call struct

+ func (_c *SBOM_GetVulnerabilities_Call) Return(vulnerabilitys *[]cyclonedx.Vulnerability) *SBOM_GetVulnerabilities_Call

+ func (_c *SBOM_GetVulnerabilities_Call) Run(run func()) *SBOM_GetVulnerabilities_Call

+ func (_c *SBOM_GetVulnerabilities_Call) RunAndReturn(run func() *[]cyclonedx.Vulnerability) *SBOM_GetVulnerabilities_Call

+ type ScanService struct

+ func NewScanService(t interface{ ... }) *ScanService

+ func (_m *ScanService) EXPECT() *ScanService_Expecter

+ func (_mock *ScanService) ScanNormalizedSBOM(org models.Org, project models.Project, asset models.Asset, ...) (int, int, []models.DependencyVuln, error)

+ type ScanService_Expecter struct

+ func (_e *ScanService_Expecter) ScanNormalizedSBOM(org interface{}, project interface{}, asset interface{}, ...) *ScanService_ScanNormalizedSBOM_Call

+ type ScanService_ScanNormalizedSBOM_Call struct

+ func (_c *ScanService_ScanNormalizedSBOM_Call) Return(n int, n1 int, dependencyVulns []models.DependencyVuln, err error) *ScanService_ScanNormalizedSBOM_Call

+ func (_c *ScanService_ScanNormalizedSBOM_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *ScanService_ScanNormalizedSBOM_Call

+ func (_c *ScanService_ScanNormalizedSBOM_Call) RunAndReturn(...) *ScanService_ScanNormalizedSBOM_Call

v0.18.9

Oct 23, 2025

v0.18.8

Oct 20, 2025

v0.18.7

Oct 20, 2025

v0.18.6

Oct 18, 2025

v0.18.5

Oct 16, 2025

Changes in this version

type AccessControl

+ func (_mock *AccessControl) AllowRoleInAsset(asset string, role core.Role, object core.Object, action []core.Action) error

+ func (_mock *AccessControl) GetAllAssetsForUser(user string) ([]string, error)

+ func (_mock *AccessControl) GetAllMembersOfAsset(projectID string) ([]string, error)

+ func (_mock *AccessControl) GetAssetRole(user string, asset string) (core.Role, error)

+ func (_mock *AccessControl) GrantRoleInAsset(subject string, role core.Role, asset string) error

+ func (_mock *AccessControl) InheritAssetRole(roleWhichGetsPermissions core.Role, roleWhichProvidesPermissions core.Role, ...) error

+ func (_mock *AccessControl) IsAllowedInAsset(asset *models.Asset, user string, object core.Object, action core.Action) (bool, error)

+ func (_mock *AccessControl) LinkProjectAndAssetRole(projectRoleWhichGetsPermission core.Role, ...) error

+ func (_mock *AccessControl) RevokeAllRolesInAssetForUser(user string, asset string) error

+ func (_mock *AccessControl) RevokeRoleInAsset(subject string, role core.Role, asset string) error

+ type AccessControl_AllowRoleInAsset_Call struct

+ func (_c *AccessControl_AllowRoleInAsset_Call) Return(err error) *AccessControl_AllowRoleInAsset_Call

+ func (_c *AccessControl_AllowRoleInAsset_Call) Run(...) *AccessControl_AllowRoleInAsset_Call

+ func (_c *AccessControl_AllowRoleInAsset_Call) RunAndReturn(...) *AccessControl_AllowRoleInAsset_Call

type AccessControl_Expecter

+ func (_e *AccessControl_Expecter) AllowRoleInAsset(asset interface{}, role interface{}, object interface{}, action interface{}) *AccessControl_AllowRoleInAsset_Call

+ func (_e *AccessControl_Expecter) GetAllAssetsForUser(user interface{}) *AccessControl_GetAllAssetsForUser_Call

+ func (_e *AccessControl_Expecter) GetAllMembersOfAsset(projectID interface{}) *AccessControl_GetAllMembersOfAsset_Call

+ func (_e *AccessControl_Expecter) GetAssetRole(user interface{}, asset interface{}) *AccessControl_GetAssetRole_Call

+ func (_e *AccessControl_Expecter) GrantRoleInAsset(subject interface{}, role interface{}, asset interface{}) *AccessControl_GrantRoleInAsset_Call

+ func (_e *AccessControl_Expecter) InheritAssetRole(roleWhichGetsPermissions interface{}, roleWhichProvidesPermissions interface{}, ...) *AccessControl_InheritAssetRole_Call

+ func (_e *AccessControl_Expecter) IsAllowedInAsset(asset interface{}, user interface{}, object interface{}, action interface{}) *AccessControl_IsAllowedInAsset_Call

+ func (_e *AccessControl_Expecter) LinkProjectAndAssetRole(projectRoleWhichGetsPermission interface{}, ...) *AccessControl_LinkProjectAndAssetRole_Call

+ func (_e *AccessControl_Expecter) RevokeAllRolesInAssetForUser(user interface{}, asset interface{}) *AccessControl_RevokeAllRolesInAssetForUser_Call

+ func (_e *AccessControl_Expecter) RevokeRoleInAsset(subject interface{}, role interface{}, asset interface{}) *AccessControl_RevokeRoleInAsset_Call

+ type AccessControl_GetAllAssetsForUser_Call struct

+ func (_c *AccessControl_GetAllAssetsForUser_Call) Return(strings []string, err error) *AccessControl_GetAllAssetsForUser_Call

+ func (_c *AccessControl_GetAllAssetsForUser_Call) Run(run func(user string)) *AccessControl_GetAllAssetsForUser_Call

+ func (_c *AccessControl_GetAllAssetsForUser_Call) RunAndReturn(run func(user string) ([]string, error)) *AccessControl_GetAllAssetsForUser_Call

+ type AccessControl_GetAllMembersOfAsset_Call struct

+ func (_c *AccessControl_GetAllMembersOfAsset_Call) Return(strings []string, err error) *AccessControl_GetAllMembersOfAsset_Call

+ func (_c *AccessControl_GetAllMembersOfAsset_Call) Run(run func(projectID string)) *AccessControl_GetAllMembersOfAsset_Call

+ func (_c *AccessControl_GetAllMembersOfAsset_Call) RunAndReturn(run func(projectID string) ([]string, error)) *AccessControl_GetAllMembersOfAsset_Call

+ type AccessControl_GetAssetRole_Call struct

+ func (_c *AccessControl_GetAssetRole_Call) Return(role core.Role, err error) *AccessControl_GetAssetRole_Call

+ func (_c *AccessControl_GetAssetRole_Call) Run(run func(user string, asset string)) *AccessControl_GetAssetRole_Call

+ func (_c *AccessControl_GetAssetRole_Call) RunAndReturn(run func(user string, asset string) (core.Role, error)) *AccessControl_GetAssetRole_Call

+ type AccessControl_GrantRoleInAsset_Call struct

+ func (_c *AccessControl_GrantRoleInAsset_Call) Return(err error) *AccessControl_GrantRoleInAsset_Call

+ func (_c *AccessControl_GrantRoleInAsset_Call) Run(run func(subject string, role core.Role, asset string)) *AccessControl_GrantRoleInAsset_Call

+ func (_c *AccessControl_GrantRoleInAsset_Call) RunAndReturn(run func(subject string, role core.Role, asset string) error) *AccessControl_GrantRoleInAsset_Call

+ type AccessControl_InheritAssetRole_Call struct

+ func (_c *AccessControl_InheritAssetRole_Call) Return(err error) *AccessControl_InheritAssetRole_Call

+ func (_c *AccessControl_InheritAssetRole_Call) Run(...) *AccessControl_InheritAssetRole_Call

+ func (_c *AccessControl_InheritAssetRole_Call) RunAndReturn(...) *AccessControl_InheritAssetRole_Call

+ type AccessControl_IsAllowedInAsset_Call struct

+ func (_c *AccessControl_IsAllowedInAsset_Call) Return(b bool, err error) *AccessControl_IsAllowedInAsset_Call

+ func (_c *AccessControl_IsAllowedInAsset_Call) Run(...) *AccessControl_IsAllowedInAsset_Call

+ func (_c *AccessControl_IsAllowedInAsset_Call) RunAndReturn(...) *AccessControl_IsAllowedInAsset_Call

+ type AccessControl_LinkProjectAndAssetRole_Call struct

+ func (_c *AccessControl_LinkProjectAndAssetRole_Call) Return(err error) *AccessControl_LinkProjectAndAssetRole_Call

+ func (_c *AccessControl_LinkProjectAndAssetRole_Call) Run(run func(projectRoleWhichGetsPermission core.Role, ...)) *AccessControl_LinkProjectAndAssetRole_Call

+ func (_c *AccessControl_LinkProjectAndAssetRole_Call) RunAndReturn(run func(projectRoleWhichGetsPermission core.Role, ...) error) *AccessControl_LinkProjectAndAssetRole_Call

+ type AccessControl_RevokeAllRolesInAssetForUser_Call struct

+ func (_c *AccessControl_RevokeAllRolesInAssetForUser_Call) Return(err error) *AccessControl_RevokeAllRolesInAssetForUser_Call

+ func (_c *AccessControl_RevokeAllRolesInAssetForUser_Call) Run(run func(user string, asset string)) *AccessControl_RevokeAllRolesInAssetForUser_Call

+ func (_c *AccessControl_RevokeAllRolesInAssetForUser_Call) RunAndReturn(run func(user string, asset string) error) *AccessControl_RevokeAllRolesInAssetForUser_Call

+ type AccessControl_RevokeRoleInAsset_Call struct

+ func (_c *AccessControl_RevokeRoleInAsset_Call) Return(err error) *AccessControl_RevokeRoleInAsset_Call

+ func (_c *AccessControl_RevokeRoleInAsset_Call) Run(run func(subject string, role core.Role, asset string)) *AccessControl_RevokeRoleInAsset_Call

+ func (_c *AccessControl_RevokeRoleInAsset_Call) RunAndReturn(run func(subject string, role core.Role, asset string) error) *AccessControl_RevokeRoleInAsset_Call

type AssetRepository

+ func (_mock *AssetRepository) GetAllowedAssetsByProjectID(allowedAssetIDs []string, projectID uuid.UUID) ([]models.Asset, error)

type AssetRepository_Expecter

+ func (_e *AssetRepository_Expecter) GetAllowedAssetsByProjectID(allowedAssetIDs interface{}, projectID interface{}) *AssetRepository_GetAllowedAssetsByProjectID_Call

+ type AssetRepository_GetAllowedAssetsByProjectID_Call struct

+ func (_c *AssetRepository_GetAllowedAssetsByProjectID_Call) Return(assets []models.Asset, err error) *AssetRepository_GetAllowedAssetsByProjectID_Call

+ func (_c *AssetRepository_GetAllowedAssetsByProjectID_Call) Run(run func(allowedAssetIDs []string, projectID uuid.UUID)) *AssetRepository_GetAllowedAssetsByProjectID_Call

+ func (_c *AssetRepository_GetAllowedAssetsByProjectID_Call) RunAndReturn(...) *AssetRepository_GetAllowedAssetsByProjectID_Call

type AssetService

+ func (_mock *AssetService) BootstrapAsset(rbac core.AccessControl, asset *models.Asset) error

+ type AssetService_BootstrapAsset_Call struct

+ func (_c *AssetService_BootstrapAsset_Call) Return(err error) *AssetService_BootstrapAsset_Call

+ func (_c *AssetService_BootstrapAsset_Call) Run(run func(rbac core.AccessControl, asset *models.Asset)) *AssetService_BootstrapAsset_Call

+ func (_c *AssetService_BootstrapAsset_Call) RunAndReturn(run func(rbac core.AccessControl, asset *models.Asset) error) *AssetService_BootstrapAsset_Call

type AssetService_Expecter

+ func (_e *AssetService_Expecter) BootstrapAsset(rbac interface{}, asset interface{}) *AssetService_BootstrapAsset_Call

v0.18.4

Oct 13, 2025

v0.18.3

Oct 10, 2025

v0.18.2

Oct 10, 2025

v0.18.1

Oct 10, 2025

v0.18.0

Oct 7, 2025

v0.17.5

Sep 26, 2025

v0.17.4

Sep 24, 2025

v0.17.3

Sep 22, 2025

Changes in this version

type GitlabClientFacade

+ func (_mock *GitlabClientFacade) CreateNewLabel(ctx context.Context, projectID int, label *gitlab.CreateLabelOptions) (*gitlab.Label, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) GetProjectIssues(projectID int, opt *gitlab.ListProjectIssuesOptions) ([]*gitlab.Issue, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) ListLabels(ctx context.Context, projectID int, opt *gitlab.ListLabelsOptions) ([]*gitlab.Label, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) UpdateLabel(ctx context.Context, projectID int, labelID int, ...) (*gitlab.Label, *gitlab.Response, error)

+ type GitlabClientFacade_CreateNewLabel_Call struct

+ func (_c *GitlabClientFacade_CreateNewLabel_Call) Return(label1 *gitlab.Label, response *gitlab.Response, err error) *GitlabClientFacade_CreateNewLabel_Call

+ func (_c *GitlabClientFacade_CreateNewLabel_Call) Run(run func(ctx context.Context, projectID int, label *gitlab.CreateLabelOptions)) *GitlabClientFacade_CreateNewLabel_Call

+ func (_c *GitlabClientFacade_CreateNewLabel_Call) RunAndReturn(...) *GitlabClientFacade_CreateNewLabel_Call

type GitlabClientFacade_Expecter

+ func (_e *GitlabClientFacade_Expecter) CreateNewLabel(ctx interface{}, projectID interface{}, label interface{}) *GitlabClientFacade_CreateNewLabel_Call

+ func (_e *GitlabClientFacade_Expecter) GetProjectIssues(projectID interface{}, opt interface{}) *GitlabClientFacade_GetProjectIssues_Call

+ func (_e *GitlabClientFacade_Expecter) ListLabels(ctx interface{}, projectID interface{}, opt interface{}) *GitlabClientFacade_ListLabels_Call

+ func (_e *GitlabClientFacade_Expecter) UpdateLabel(ctx interface{}, projectID interface{}, labelID interface{}, opt interface{}) *GitlabClientFacade_UpdateLabel_Call

+ type GitlabClientFacade_GetProjectIssues_Call struct

+ func (_c *GitlabClientFacade_GetProjectIssues_Call) Return(issues []*gitlab.Issue, response *gitlab.Response, err error) *GitlabClientFacade_GetProjectIssues_Call

+ func (_c *GitlabClientFacade_GetProjectIssues_Call) Run(run func(projectID int, opt *gitlab.ListProjectIssuesOptions)) *GitlabClientFacade_GetProjectIssues_Call

+ func (_c *GitlabClientFacade_GetProjectIssues_Call) RunAndReturn(...) *GitlabClientFacade_GetProjectIssues_Call

+ type GitlabClientFacade_ListLabels_Call struct

+ func (_c *GitlabClientFacade_ListLabels_Call) Return(labels []*gitlab.Label, response *gitlab.Response, err error) *GitlabClientFacade_ListLabels_Call

+ func (_c *GitlabClientFacade_ListLabels_Call) Run(run func(ctx context.Context, projectID int, opt *gitlab.ListLabelsOptions)) *GitlabClientFacade_ListLabels_Call

+ func (_c *GitlabClientFacade_ListLabels_Call) RunAndReturn(...) *GitlabClientFacade_ListLabels_Call

+ type GitlabClientFacade_UpdateLabel_Call struct

+ func (_c *GitlabClientFacade_UpdateLabel_Call) Return(label *gitlab.Label, response *gitlab.Response, err error) *GitlabClientFacade_UpdateLabel_Call

+ func (_c *GitlabClientFacade_UpdateLabel_Call) Run(run func(ctx context.Context, projectID int, labelID int, ...)) *GitlabClientFacade_UpdateLabel_Call

+ func (_c *GitlabClientFacade_UpdateLabel_Call) RunAndReturn(...) *GitlabClientFacade_UpdateLabel_Call

type IntegrationAggregate

+ func (_mock *IntegrationAggregate) CreateLabels(ctx context.Context, asset models.Asset) error

+ type IntegrationAggregate_CreateLabels_Call struct

+ func (_c *IntegrationAggregate_CreateLabels_Call) Return(err error) *IntegrationAggregate_CreateLabels_Call

+ func (_c *IntegrationAggregate_CreateLabels_Call) Run(run func(ctx context.Context, asset models.Asset)) *IntegrationAggregate_CreateLabels_Call

+ func (_c *IntegrationAggregate_CreateLabels_Call) RunAndReturn(run func(ctx context.Context, asset models.Asset) error) *IntegrationAggregate_CreateLabels_Call

type IntegrationAggregate_Expecter

+ func (_e *IntegrationAggregate_Expecter) CreateLabels(ctx interface{}, asset interface{}) *IntegrationAggregate_CreateLabels_Call

type ThirdPartyIntegration

+ func (_mock *ThirdPartyIntegration) CreateLabels(ctx context.Context, asset models.Asset) error

+ type ThirdPartyIntegration_CreateLabels_Call struct

+ func (_c *ThirdPartyIntegration_CreateLabels_Call) Return(err error) *ThirdPartyIntegration_CreateLabels_Call

+ func (_c *ThirdPartyIntegration_CreateLabels_Call) Run(run func(ctx context.Context, asset models.Asset)) *ThirdPartyIntegration_CreateLabels_Call

+ func (_c *ThirdPartyIntegration_CreateLabels_Call) RunAndReturn(run func(ctx context.Context, asset models.Asset) error) *ThirdPartyIntegration_CreateLabels_Call

type ThirdPartyIntegration_Expecter

+ func (_e *ThirdPartyIntegration_Expecter) CreateLabels(ctx interface{}, asset interface{}) *ThirdPartyIntegration_CreateLabels_Call

v0.17.2

Sep 17, 2025

v0.17.1

Sep 17, 2025

v0.17.0

Sep 17, 2025

Changes in this version

+ type AccessControl struct

+ func NewAccessControl(t interface{ ... }) *AccessControl

+ func (_m *AccessControl) EXPECT() *AccessControl_Expecter

+ func (_mock *AccessControl) AllowRole(role core.Role, object core.Object, action []core.Action) error

+ func (_mock *AccessControl) AllowRoleInProject(project string, role core.Role, object core.Object, action []core.Action) error

+ func (_mock *AccessControl) GetAllMembersOfOrganization() ([]string, error)

+ func (_mock *AccessControl) GetAllMembersOfProject(projectID string) ([]string, error)

+ func (_mock *AccessControl) GetAllProjectsForUser(user string) ([]string, error)

+ func (_mock *AccessControl) GetAllRoles(user string) []string

+ func (_mock *AccessControl) GetDomainRole(user string) (core.Role, error)

+ func (_mock *AccessControl) GetExternalEntityProviderID() *string

+ func (_mock *AccessControl) GetOwnerOfOrganization() (string, error)

+ func (_mock *AccessControl) GetProjectRole(user string, project string) (core.Role, error)

+ func (_mock *AccessControl) GrantRole(subject string, role core.Role) error

+ func (_mock *AccessControl) GrantRoleInProject(subject string, role core.Role, project string) error

+ func (_mock *AccessControl) HasAccess(subject string) (bool, error)

+ func (_mock *AccessControl) InheritProjectRole(roleWhichGetsPermissions core.Role, roleWhichProvidesPermissions core.Role, ...) error

+ func (_mock *AccessControl) InheritProjectRolesAcrossProjects(roleWhichGetsPermissions core.ProjectRole, ...) error

+ func (_mock *AccessControl) InheritRole(roleWhichGetsPermissions core.Role, roleWhichProvidesPermissions core.Role) error

+ func (_mock *AccessControl) IsAllowed(subject string, object core.Object, action core.Action) (bool, error)

+ func (_mock *AccessControl) IsAllowedInProject(project *models.Project, user string, object core.Object, action core.Action) (bool, error)

+ func (_mock *AccessControl) LinkDomainAndProjectRole(domainRoleWhichGetsPermission core.Role, ...) error

+ func (_mock *AccessControl) RevokeAllRolesInProjectForUser(user string, project string) error

+ func (_mock *AccessControl) RevokeRole(subject string, role core.Role) error

+ func (_mock *AccessControl) RevokeRoleInProject(subject string, role core.Role, project string) error

+ type AccessControl_AllowRoleInProject_Call struct

+ func (_c *AccessControl_AllowRoleInProject_Call) Return(err error) *AccessControl_AllowRoleInProject_Call

+ func (_c *AccessControl_AllowRoleInProject_Call) Run(...) *AccessControl_AllowRoleInProject_Call

+ func (_c *AccessControl_AllowRoleInProject_Call) RunAndReturn(...) *AccessControl_AllowRoleInProject_Call

+ type AccessControl_AllowRole_Call struct

+ func (_c *AccessControl_AllowRole_Call) Return(err error) *AccessControl_AllowRole_Call

+ func (_c *AccessControl_AllowRole_Call) Run(run func(role core.Role, object core.Object, action []core.Action)) *AccessControl_AllowRole_Call

+ func (_c *AccessControl_AllowRole_Call) RunAndReturn(run func(role core.Role, object core.Object, action []core.Action) error) *AccessControl_AllowRole_Call

+ type AccessControl_Expecter struct

+ func (_e *AccessControl_Expecter) AllowRole(role interface{}, object interface{}, action interface{}) *AccessControl_AllowRole_Call

+ func (_e *AccessControl_Expecter) AllowRoleInProject(project interface{}, role interface{}, object interface{}, action interface{}) *AccessControl_AllowRoleInProject_Call

+ func (_e *AccessControl_Expecter) GetAllMembersOfOrganization() *AccessControl_GetAllMembersOfOrganization_Call

+ func (_e *AccessControl_Expecter) GetAllMembersOfProject(projectID interface{}) *AccessControl_GetAllMembersOfProject_Call

+ func (_e *AccessControl_Expecter) GetAllProjectsForUser(user interface{}) *AccessControl_GetAllProjectsForUser_Call

+ func (_e *AccessControl_Expecter) GetAllRoles(user interface{}) *AccessControl_GetAllRoles_Call

+ func (_e *AccessControl_Expecter) GetDomainRole(user interface{}) *AccessControl_GetDomainRole_Call

+ func (_e *AccessControl_Expecter) GetExternalEntityProviderID() *AccessControl_GetExternalEntityProviderID_Call

+ func (_e *AccessControl_Expecter) GetOwnerOfOrganization() *AccessControl_GetOwnerOfOrganization_Call

+ func (_e *AccessControl_Expecter) GetProjectRole(user interface{}, project interface{}) *AccessControl_GetProjectRole_Call

+ func (_e *AccessControl_Expecter) GrantRole(subject interface{}, role interface{}) *AccessControl_GrantRole_Call

+ func (_e *AccessControl_Expecter) GrantRoleInProject(subject interface{}, role interface{}, project interface{}) *AccessControl_GrantRoleInProject_Call

+ func (_e *AccessControl_Expecter) HasAccess(subject interface{}) *AccessControl_HasAccess_Call

+ func (_e *AccessControl_Expecter) InheritProjectRole(roleWhichGetsPermissions interface{}, roleWhichProvidesPermissions interface{}, ...) *AccessControl_InheritProjectRole_Call

+ func (_e *AccessControl_Expecter) InheritProjectRolesAcrossProjects(roleWhichGetsPermissions interface{}, roleWhichProvidesPermissions interface{}) *AccessControl_InheritProjectRolesAcrossProjects_Call

+ func (_e *AccessControl_Expecter) InheritRole(roleWhichGetsPermissions interface{}, roleWhichProvidesPermissions interface{}) *AccessControl_InheritRole_Call

+ func (_e *AccessControl_Expecter) IsAllowed(subject interface{}, object interface{}, action interface{}) *AccessControl_IsAllowed_Call

+ func (_e *AccessControl_Expecter) IsAllowedInProject(project interface{}, user interface{}, object interface{}, action interface{}) *AccessControl_IsAllowedInProject_Call

+ func (_e *AccessControl_Expecter) LinkDomainAndProjectRole(domainRoleWhichGetsPermission interface{}, ...) *AccessControl_LinkDomainAndProjectRole_Call

+ func (_e *AccessControl_Expecter) RevokeAllRolesInProjectForUser(user interface{}, project interface{}) *AccessControl_RevokeAllRolesInProjectForUser_Call

+ func (_e *AccessControl_Expecter) RevokeRole(subject interface{}, role interface{}) *AccessControl_RevokeRole_Call

+ func (_e *AccessControl_Expecter) RevokeRoleInProject(subject interface{}, role interface{}, project interface{}) *AccessControl_RevokeRoleInProject_Call

+ type AccessControl_GetAllMembersOfOrganization_Call struct

+ func (_c *AccessControl_GetAllMembersOfOrganization_Call) Return(strings []string, err error) *AccessControl_GetAllMembersOfOrganization_Call

+ func (_c *AccessControl_GetAllMembersOfOrganization_Call) Run(run func()) *AccessControl_GetAllMembersOfOrganization_Call

+ func (_c *AccessControl_GetAllMembersOfOrganization_Call) RunAndReturn(run func() ([]string, error)) *AccessControl_GetAllMembersOfOrganization_Call

+ type AccessControl_GetAllMembersOfProject_Call struct

+ func (_c *AccessControl_GetAllMembersOfProject_Call) Return(strings []string, err error) *AccessControl_GetAllMembersOfProject_Call

+ func (_c *AccessControl_GetAllMembersOfProject_Call) Run(run func(projectID string)) *AccessControl_GetAllMembersOfProject_Call

+ func (_c *AccessControl_GetAllMembersOfProject_Call) RunAndReturn(run func(projectID string) ([]string, error)) *AccessControl_GetAllMembersOfProject_Call

+ type AccessControl_GetAllProjectsForUser_Call struct

+ func (_c *AccessControl_GetAllProjectsForUser_Call) Return(strings []string, err error) *AccessControl_GetAllProjectsForUser_Call

+ func (_c *AccessControl_GetAllProjectsForUser_Call) Run(run func(user string)) *AccessControl_GetAllProjectsForUser_Call

+ func (_c *AccessControl_GetAllProjectsForUser_Call) RunAndReturn(run func(user string) ([]string, error)) *AccessControl_GetAllProjectsForUser_Call

+ type AccessControl_GetAllRoles_Call struct

+ func (_c *AccessControl_GetAllRoles_Call) Return(strings []string) *AccessControl_GetAllRoles_Call

+ func (_c *AccessControl_GetAllRoles_Call) Run(run func(user string)) *AccessControl_GetAllRoles_Call

+ func (_c *AccessControl_GetAllRoles_Call) RunAndReturn(run func(user string) []string) *AccessControl_GetAllRoles_Call

+ type AccessControl_GetDomainRole_Call struct

+ func (_c *AccessControl_GetDomainRole_Call) Return(role core.Role, err error) *AccessControl_GetDomainRole_Call

+ func (_c *AccessControl_GetDomainRole_Call) Run(run func(user string)) *AccessControl_GetDomainRole_Call

+ func (_c *AccessControl_GetDomainRole_Call) RunAndReturn(run func(user string) (core.Role, error)) *AccessControl_GetDomainRole_Call

+ type AccessControl_GetExternalEntityProviderID_Call struct

+ func (_c *AccessControl_GetExternalEntityProviderID_Call) Return(s *string) *AccessControl_GetExternalEntityProviderID_Call

+ func (_c *AccessControl_GetExternalEntityProviderID_Call) Run(run func()) *AccessControl_GetExternalEntityProviderID_Call

+ func (_c *AccessControl_GetExternalEntityProviderID_Call) RunAndReturn(run func() *string) *AccessControl_GetExternalEntityProviderID_Call

+ type AccessControl_GetOwnerOfOrganization_Call struct

+ func (_c *AccessControl_GetOwnerOfOrganization_Call) Return(s string, err error) *AccessControl_GetOwnerOfOrganization_Call

+ func (_c *AccessControl_GetOwnerOfOrganization_Call) Run(run func()) *AccessControl_GetOwnerOfOrganization_Call

+ func (_c *AccessControl_GetOwnerOfOrganization_Call) RunAndReturn(run func() (string, error)) *AccessControl_GetOwnerOfOrganization_Call

+ type AccessControl_GetProjectRole_Call struct

+ func (_c *AccessControl_GetProjectRole_Call) Return(role core.Role, err error) *AccessControl_GetProjectRole_Call

+ func (_c *AccessControl_GetProjectRole_Call) Run(run func(user string, project string)) *AccessControl_GetProjectRole_Call

+ func (_c *AccessControl_GetProjectRole_Call) RunAndReturn(run func(user string, project string) (core.Role, error)) *AccessControl_GetProjectRole_Call

+ type AccessControl_GrantRoleInProject_Call struct

+ func (_c *AccessControl_GrantRoleInProject_Call) Return(err error) *AccessControl_GrantRoleInProject_Call

+ func (_c *AccessControl_GrantRoleInProject_Call) Run(run func(subject string, role core.Role, project string)) *AccessControl_GrantRoleInProject_Call

+ func (_c *AccessControl_GrantRoleInProject_Call) RunAndReturn(run func(subject string, role core.Role, project string) error) *AccessControl_GrantRoleInProject_Call

+ type AccessControl_GrantRole_Call struct

+ func (_c *AccessControl_GrantRole_Call) Return(err error) *AccessControl_GrantRole_Call

+ func (_c *AccessControl_GrantRole_Call) Run(run func(subject string, role core.Role)) *AccessControl_GrantRole_Call

+ func (_c *AccessControl_GrantRole_Call) RunAndReturn(run func(subject string, role core.Role) error) *AccessControl_GrantRole_Call

+ type AccessControl_HasAccess_Call struct

+ func (_c *AccessControl_HasAccess_Call) Return(b bool, err error) *AccessControl_HasAccess_Call

+ func (_c *AccessControl_HasAccess_Call) Run(run func(subject string)) *AccessControl_HasAccess_Call

+ func (_c *AccessControl_HasAccess_Call) RunAndReturn(run func(subject string) (bool, error)) *AccessControl_HasAccess_Call

+ type AccessControl_InheritProjectRole_Call struct

+ func (_c *AccessControl_InheritProjectRole_Call) Return(err error) *AccessControl_InheritProjectRole_Call

+ func (_c *AccessControl_InheritProjectRole_Call) Run(...) *AccessControl_InheritProjectRole_Call

+ func (_c *AccessControl_InheritProjectRole_Call) RunAndReturn(...) *AccessControl_InheritProjectRole_Call

+ type AccessControl_InheritProjectRolesAcrossProjects_Call struct

+ func (_c *AccessControl_InheritProjectRolesAcrossProjects_Call) Return(err error) *AccessControl_InheritProjectRolesAcrossProjects_Call

+ func (_c *AccessControl_InheritProjectRolesAcrossProjects_Call) Run(run func(roleWhichGetsPermissions core.ProjectRole, ...)) *AccessControl_InheritProjectRolesAcrossProjects_Call

+ func (_c *AccessControl_InheritProjectRolesAcrossProjects_Call) RunAndReturn(run func(roleWhichGetsPermissions core.ProjectRole, ...) error) *AccessControl_InheritProjectRolesAcrossProjects_Call

+ type AccessControl_InheritRole_Call struct

+ func (_c *AccessControl_InheritRole_Call) Return(err error) *AccessControl_InheritRole_Call

+ func (_c *AccessControl_InheritRole_Call) Run(...) *AccessControl_InheritRole_Call

+ func (_c *AccessControl_InheritRole_Call) RunAndReturn(...) *AccessControl_InheritRole_Call

+ type AccessControl_IsAllowedInProject_Call struct

+ func (_c *AccessControl_IsAllowedInProject_Call) Return(b bool, err error) *AccessControl_IsAllowedInProject_Call

+ func (_c *AccessControl_IsAllowedInProject_Call) Run(...) *AccessControl_IsAllowedInProject_Call

+ func (_c *AccessControl_IsAllowedInProject_Call) RunAndReturn(...) *AccessControl_IsAllowedInProject_Call

+ type AccessControl_IsAllowed_Call struct

+ func (_c *AccessControl_IsAllowed_Call) Return(b bool, err error) *AccessControl_IsAllowed_Call

+ func (_c *AccessControl_IsAllowed_Call) Run(run func(subject string, object core.Object, action core.Action)) *AccessControl_IsAllowed_Call

+ func (_c *AccessControl_IsAllowed_Call) RunAndReturn(run func(subject string, object core.Object, action core.Action) (bool, error)) *AccessControl_IsAllowed_Call

+ type AccessControl_LinkDomainAndProjectRole_Call struct

+ func (_c *AccessControl_LinkDomainAndProjectRole_Call) Return(err error) *AccessControl_LinkDomainAndProjectRole_Call

+ func (_c *AccessControl_LinkDomainAndProjectRole_Call) Run(run func(domainRoleWhichGetsPermission core.Role, ...)) *AccessControl_LinkDomainAndProjectRole_Call

+ func (_c *AccessControl_LinkDomainAndProjectRole_Call) RunAndReturn(run func(domainRoleWhichGetsPermission core.Role, ...) error) *AccessControl_LinkDomainAndProjectRole_Call

+ type AccessControl_RevokeAllRolesInProjectForUser_Call struct

+ func (_c *AccessControl_RevokeAllRolesInProjectForUser_Call) Return(err error) *AccessControl_RevokeAllRolesInProjectForUser_Call

+ func (_c *AccessControl_RevokeAllRolesInProjectForUser_Call) Run(run func(user string, project string)) *AccessControl_RevokeAllRolesInProjectForUser_Call

+ func (_c *AccessControl_RevokeAllRolesInProjectForUser_Call) RunAndReturn(run func(user string, project string) error) *AccessControl_RevokeAllRolesInProjectForUser_Call

+ type AccessControl_RevokeRoleInProject_Call struct

+ func (_c *AccessControl_RevokeRoleInProject_Call) Return(err error) *AccessControl_RevokeRoleInProject_Call

+ func (_c *AccessControl_RevokeRoleInProject_Call) Run(run func(subject string, role core.Role, project string)) *AccessControl_RevokeRoleInProject_Call

+ func (_c *AccessControl_RevokeRoleInProject_Call) RunAndReturn(run func(subject string, role core.Role, project string) error) *AccessControl_RevokeRoleInProject_Call

+ type AccessControl_RevokeRole_Call struct

+ func (_c *AccessControl_RevokeRole_Call) Return(err error) *AccessControl_RevokeRole_Call

+ func (_c *AccessControl_RevokeRole_Call) Run(run func(subject string, role core.Role)) *AccessControl_RevokeRole_Call

+ func (_c *AccessControl_RevokeRole_Call) RunAndReturn(run func(subject string, role core.Role) error) *AccessControl_RevokeRole_Call

+ type AdminClient struct

+ func NewAdminClient(t interface{ ... }) *AdminClient

+ func (_m *AdminClient) EXPECT() *AdminClient_Expecter

+ func (_mock *AdminClient) GetIdentity(ctx context.Context, userID string) (client.Identity, error)

+ func (_mock *AdminClient) GetIdentityFromCookie(ctx context.Context, cookie string) (client.Identity, error)

+ func (_mock *AdminClient) GetIdentityWithCredentials(ctx context.Context, userID string) (client.Identity, error)

+ func (_mock *AdminClient) ListUser(client1 client.IdentityAPIListIdentitiesRequest) ([]client.Identity, error)

+ type AdminClient_Expecter struct

+ func (_e *AdminClient_Expecter) GetIdentity(ctx interface{}, userID interface{}) *AdminClient_GetIdentity_Call

+ func (_e *AdminClient_Expecter) GetIdentityFromCookie(ctx interface{}, cookie interface{}) *AdminClient_GetIdentityFromCookie_Call

+ func (_e *AdminClient_Expecter) GetIdentityWithCredentials(ctx interface{}, userID interface{}) *AdminClient_GetIdentityWithCredentials_Call

+ func (_e *AdminClient_Expecter) ListUser(client1 interface{}) *AdminClient_ListUser_Call

+ type AdminClient_GetIdentityFromCookie_Call struct

+ func (_c *AdminClient_GetIdentityFromCookie_Call) Return(identity client.Identity, err error) *AdminClient_GetIdentityFromCookie_Call

+ func (_c *AdminClient_GetIdentityFromCookie_Call) Run(run func(ctx context.Context, cookie string)) *AdminClient_GetIdentityFromCookie_Call

+ func (_c *AdminClient_GetIdentityFromCookie_Call) RunAndReturn(run func(ctx context.Context, cookie string) (client.Identity, error)) *AdminClient_GetIdentityFromCookie_Call

+ type AdminClient_GetIdentityWithCredentials_Call struct

+ func (_c *AdminClient_GetIdentityWithCredentials_Call) Return(identity client.Identity, err error) *AdminClient_GetIdentityWithCredentials_Call

+ func (_c *AdminClient_GetIdentityWithCredentials_Call) Run(run func(ctx context.Context, userID string)) *AdminClient_GetIdentityWithCredentials_Call

+ func (_c *AdminClient_GetIdentityWithCredentials_Call) RunAndReturn(run func(ctx context.Context, userID string) (client.Identity, error)) *AdminClient_GetIdentityWithCredentials_Call

+ type AdminClient_GetIdentity_Call struct

+ func (_c *AdminClient_GetIdentity_Call) Return(identity client.Identity, err error) *AdminClient_GetIdentity_Call

+ func (_c *AdminClient_GetIdentity_Call) Run(run func(ctx context.Context, userID string)) *AdminClient_GetIdentity_Call

+ func (_c *AdminClient_GetIdentity_Call) RunAndReturn(run func(ctx context.Context, userID string) (client.Identity, error)) *AdminClient_GetIdentity_Call

+ type AdminClient_ListUser_Call struct

+ func (_c *AdminClient_ListUser_Call) Return(identitys []client.Identity, err error) *AdminClient_ListUser_Call

+ func (_c *AdminClient_ListUser_Call) Run(run func(client1 client.IdentityAPIListIdentitiesRequest)) *AdminClient_ListUser_Call

+ func (_c *AdminClient_ListUser_Call) RunAndReturn(...) *AdminClient_ListUser_Call

+ type AffectedComponentRepository struct

+ func NewAffectedComponentRepository(t interface{ ... }) *AffectedComponentRepository

+ func (_m *AffectedComponentRepository) EXPECT() *AffectedComponentRepository_Expecter

+ func (_mock *AffectedComponentRepository) Activate(tx core.DB, id string) error

+ func (_mock *AffectedComponentRepository) All() ([]models.AffectedComponent, error)

+ func (_mock *AffectedComponentRepository) Begin() core.DB

+ func (_mock *AffectedComponentRepository) Create(tx core.DB, t *models.AffectedComponent) error

+ func (_mock *AffectedComponentRepository) CreateBatch(tx core.DB, ts []models.AffectedComponent) error

+ func (_mock *AffectedComponentRepository) Delete(tx core.DB, id string) error

+ func (_mock *AffectedComponentRepository) DeleteAll(tx core.DB, ecosystem string) error

+ func (_mock *AffectedComponentRepository) DeleteBatch(tx core.DB, ids []models.AffectedComponent) error

+ func (_mock *AffectedComponentRepository) GetAllAffectedComponentsID() ([]string, error)

+ func (_mock *AffectedComponentRepository) GetDB(tx core.DB) core.DB

+ func (_mock *AffectedComponentRepository) List(ids []string) ([]models.AffectedComponent, error)

+ func (_mock *AffectedComponentRepository) Read(id string) (models.AffectedComponent, error)

+ func (_mock *AffectedComponentRepository) Save(tx core.DB, affectedComponent *models.AffectedComponent) error

+ func (_mock *AffectedComponentRepository) SaveBatch(tx core.DB, affectedPkgs []models.AffectedComponent) error

+ func (_mock *AffectedComponentRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *AffectedComponentRepository) Upsert(t *[]*models.AffectedComponent, conflictingColumns []clause.Column, ...) error

+ type AffectedComponentRepository_Activate_Call struct

+ func (_c *AffectedComponentRepository_Activate_Call) Return(err error) *AffectedComponentRepository_Activate_Call

+ func (_c *AffectedComponentRepository_Activate_Call) Run(run func(tx core.DB, id string)) *AffectedComponentRepository_Activate_Call

+ func (_c *AffectedComponentRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *AffectedComponentRepository_Activate_Call

+ type AffectedComponentRepository_All_Call struct

+ func (_c *AffectedComponentRepository_All_Call) Return(affectedComponents []models.AffectedComponent, err error) *AffectedComponentRepository_All_Call

+ func (_c *AffectedComponentRepository_All_Call) Run(run func()) *AffectedComponentRepository_All_Call

+ func (_c *AffectedComponentRepository_All_Call) RunAndReturn(run func() ([]models.AffectedComponent, error)) *AffectedComponentRepository_All_Call

+ type AffectedComponentRepository_Begin_Call struct

+ func (_c *AffectedComponentRepository_Begin_Call) Return(v core.DB) *AffectedComponentRepository_Begin_Call

+ func (_c *AffectedComponentRepository_Begin_Call) Run(run func()) *AffectedComponentRepository_Begin_Call

+ func (_c *AffectedComponentRepository_Begin_Call) RunAndReturn(run func() core.DB) *AffectedComponentRepository_Begin_Call

+ type AffectedComponentRepository_CreateBatch_Call struct

+ func (_c *AffectedComponentRepository_CreateBatch_Call) Return(err error) *AffectedComponentRepository_CreateBatch_Call

+ func (_c *AffectedComponentRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.AffectedComponent)) *AffectedComponentRepository_CreateBatch_Call

+ func (_c *AffectedComponentRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.AffectedComponent) error) *AffectedComponentRepository_CreateBatch_Call

+ type AffectedComponentRepository_Create_Call struct

+ func (_c *AffectedComponentRepository_Create_Call) Return(err error) *AffectedComponentRepository_Create_Call

+ func (_c *AffectedComponentRepository_Create_Call) Run(run func(tx core.DB, t *models.AffectedComponent)) *AffectedComponentRepository_Create_Call

+ func (_c *AffectedComponentRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.AffectedComponent) error) *AffectedComponentRepository_Create_Call

+ type AffectedComponentRepository_DeleteAll_Call struct

+ func (_c *AffectedComponentRepository_DeleteAll_Call) Return(err error) *AffectedComponentRepository_DeleteAll_Call

+ func (_c *AffectedComponentRepository_DeleteAll_Call) Run(run func(tx core.DB, ecosystem string)) *AffectedComponentRepository_DeleteAll_Call

+ func (_c *AffectedComponentRepository_DeleteAll_Call) RunAndReturn(run func(tx core.DB, ecosystem string) error) *AffectedComponentRepository_DeleteAll_Call

+ type AffectedComponentRepository_DeleteBatch_Call struct

+ func (_c *AffectedComponentRepository_DeleteBatch_Call) Return(err error) *AffectedComponentRepository_DeleteBatch_Call

+ func (_c *AffectedComponentRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.AffectedComponent)) *AffectedComponentRepository_DeleteBatch_Call

+ func (_c *AffectedComponentRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.AffectedComponent) error) *AffectedComponentRepository_DeleteBatch_Call

+ type AffectedComponentRepository_Delete_Call struct

+ func (_c *AffectedComponentRepository_Delete_Call) Return(err error) *AffectedComponentRepository_Delete_Call

+ func (_c *AffectedComponentRepository_Delete_Call) Run(run func(tx core.DB, id string)) *AffectedComponentRepository_Delete_Call

+ func (_c *AffectedComponentRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *AffectedComponentRepository_Delete_Call

+ type AffectedComponentRepository_Expecter struct

+ func (_e *AffectedComponentRepository_Expecter) Activate(tx interface{}, id interface{}) *AffectedComponentRepository_Activate_Call

+ func (_e *AffectedComponentRepository_Expecter) All() *AffectedComponentRepository_All_Call

+ func (_e *AffectedComponentRepository_Expecter) Begin() *AffectedComponentRepository_Begin_Call

+ func (_e *AffectedComponentRepository_Expecter) Create(tx interface{}, t interface{}) *AffectedComponentRepository_Create_Call

+ func (_e *AffectedComponentRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *AffectedComponentRepository_CreateBatch_Call

+ func (_e *AffectedComponentRepository_Expecter) Delete(tx interface{}, id interface{}) *AffectedComponentRepository_Delete_Call

+ func (_e *AffectedComponentRepository_Expecter) DeleteAll(tx interface{}, ecosystem interface{}) *AffectedComponentRepository_DeleteAll_Call

+ func (_e *AffectedComponentRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *AffectedComponentRepository_DeleteBatch_Call

+ func (_e *AffectedComponentRepository_Expecter) GetAllAffectedComponentsID() *AffectedComponentRepository_GetAllAffectedComponentsID_Call

+ func (_e *AffectedComponentRepository_Expecter) GetDB(tx interface{}) *AffectedComponentRepository_GetDB_Call

+ func (_e *AffectedComponentRepository_Expecter) List(ids interface{}) *AffectedComponentRepository_List_Call

+ func (_e *AffectedComponentRepository_Expecter) Read(id interface{}) *AffectedComponentRepository_Read_Call

+ func (_e *AffectedComponentRepository_Expecter) Save(tx interface{}, affectedComponent interface{}) *AffectedComponentRepository_Save_Call

+ func (_e *AffectedComponentRepository_Expecter) SaveBatch(tx interface{}, affectedPkgs interface{}) *AffectedComponentRepository_SaveBatch_Call

+ func (_e *AffectedComponentRepository_Expecter) Transaction(fn interface{}) *AffectedComponentRepository_Transaction_Call

+ func (_e *AffectedComponentRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *AffectedComponentRepository_Upsert_Call

+ type AffectedComponentRepository_GetAllAffectedComponentsID_Call struct

+ func (_c *AffectedComponentRepository_GetAllAffectedComponentsID_Call) Return(strings []string, err error) *AffectedComponentRepository_GetAllAffectedComponentsID_Call

+ func (_c *AffectedComponentRepository_GetAllAffectedComponentsID_Call) Run(run func()) *AffectedComponentRepository_GetAllAffectedComponentsID_Call

+ func (_c *AffectedComponentRepository_GetAllAffectedComponentsID_Call) RunAndReturn(run func() ([]string, error)) *AffectedComponentRepository_GetAllAffectedComponentsID_Call

+ type AffectedComponentRepository_GetDB_Call struct

+ func (_c *AffectedComponentRepository_GetDB_Call) Return(v core.DB) *AffectedComponentRepository_GetDB_Call

+ func (_c *AffectedComponentRepository_GetDB_Call) Run(run func(tx core.DB)) *AffectedComponentRepository_GetDB_Call

+ func (_c *AffectedComponentRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *AffectedComponentRepository_GetDB_Call

+ type AffectedComponentRepository_List_Call struct

+ func (_c *AffectedComponentRepository_List_Call) Return(affectedComponents []models.AffectedComponent, err error) *AffectedComponentRepository_List_Call

+ func (_c *AffectedComponentRepository_List_Call) Run(run func(ids []string)) *AffectedComponentRepository_List_Call

+ func (_c *AffectedComponentRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.AffectedComponent, error)) *AffectedComponentRepository_List_Call

+ type AffectedComponentRepository_Read_Call struct

+ func (_c *AffectedComponentRepository_Read_Call) Return(affectedComponent models.AffectedComponent, err error) *AffectedComponentRepository_Read_Call

+ func (_c *AffectedComponentRepository_Read_Call) Run(run func(id string)) *AffectedComponentRepository_Read_Call

+ func (_c *AffectedComponentRepository_Read_Call) RunAndReturn(run func(id string) (models.AffectedComponent, error)) *AffectedComponentRepository_Read_Call

+ type AffectedComponentRepository_SaveBatch_Call struct

+ func (_c *AffectedComponentRepository_SaveBatch_Call) Return(err error) *AffectedComponentRepository_SaveBatch_Call

+ func (_c *AffectedComponentRepository_SaveBatch_Call) Run(run func(tx core.DB, affectedPkgs []models.AffectedComponent)) *AffectedComponentRepository_SaveBatch_Call

+ func (_c *AffectedComponentRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, affectedPkgs []models.AffectedComponent) error) *AffectedComponentRepository_SaveBatch_Call

+ type AffectedComponentRepository_Save_Call struct

+ func (_c *AffectedComponentRepository_Save_Call) Return(err error) *AffectedComponentRepository_Save_Call

+ func (_c *AffectedComponentRepository_Save_Call) Run(run func(tx core.DB, affectedComponent *models.AffectedComponent)) *AffectedComponentRepository_Save_Call

+ func (_c *AffectedComponentRepository_Save_Call) RunAndReturn(run func(tx core.DB, affectedComponent *models.AffectedComponent) error) *AffectedComponentRepository_Save_Call

+ type AffectedComponentRepository_Transaction_Call struct

+ func (_c *AffectedComponentRepository_Transaction_Call) Return(err error) *AffectedComponentRepository_Transaction_Call

+ func (_c *AffectedComponentRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *AffectedComponentRepository_Transaction_Call

+ func (_c *AffectedComponentRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *AffectedComponentRepository_Transaction_Call

+ type AffectedComponentRepository_Upsert_Call struct

+ func (_c *AffectedComponentRepository_Upsert_Call) Return(err error) *AffectedComponentRepository_Upsert_Call

+ func (_c *AffectedComponentRepository_Upsert_Call) Run(...) *AffectedComponentRepository_Upsert_Call

+ func (_c *AffectedComponentRepository_Upsert_Call) RunAndReturn(...) *AffectedComponentRepository_Upsert_Call

+ type ArtifactRepository struct

+ func NewArtifactRepository(t interface{ ... }) *ArtifactRepository

+ func (_m *ArtifactRepository) EXPECT() *ArtifactRepository_Expecter

+ func (_mock *ArtifactRepository) Activate(tx core.DB, id string) error

+ func (_mock *ArtifactRepository) All() ([]models.Artifact, error)

+ func (_mock *ArtifactRepository) Begin() core.DB

+ func (_mock *ArtifactRepository) Create(tx core.DB, t *models.Artifact) error

+ func (_mock *ArtifactRepository) CreateBatch(tx core.DB, ts []models.Artifact) error

+ func (_mock *ArtifactRepository) Delete(tx core.DB, id string) error

+ func (_mock *ArtifactRepository) DeleteArtifact(assetID uuid.UUID, assetVersionName string, artifactName string) error

+ func (_mock *ArtifactRepository) DeleteBatch(tx core.DB, ids []models.Artifact) error

+ func (_mock *ArtifactRepository) GetByAssetIDAndAssetVersionName(assetID uuid.UUID, assetVersionName string) ([]models.Artifact, error)

+ func (_mock *ArtifactRepository) GetDB(tx core.DB) core.DB

+ func (_mock *ArtifactRepository) List(ids []string) ([]models.Artifact, error)

+ func (_mock *ArtifactRepository) Read(id string) (models.Artifact, error)

+ func (_mock *ArtifactRepository) ReadArtifact(name string, assetVersionName string, assetID uuid.UUID) (models.Artifact, error)

+ func (_mock *ArtifactRepository) Save(tx core.DB, t *models.Artifact) error

+ func (_mock *ArtifactRepository) SaveBatch(tx core.DB, ts []models.Artifact) error

+ func (_mock *ArtifactRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *ArtifactRepository) Upsert(t *[]*models.Artifact, conflictingColumns []clause.Column, updateOnly []string) error

+ type ArtifactRepository_Activate_Call struct

+ func (_c *ArtifactRepository_Activate_Call) Return(err error) *ArtifactRepository_Activate_Call

+ func (_c *ArtifactRepository_Activate_Call) Run(run func(tx core.DB, id string)) *ArtifactRepository_Activate_Call

+ func (_c *ArtifactRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *ArtifactRepository_Activate_Call

+ type ArtifactRepository_All_Call struct

+ func (_c *ArtifactRepository_All_Call) Return(artifacts []models.Artifact, err error) *ArtifactRepository_All_Call

+ func (_c *ArtifactRepository_All_Call) Run(run func()) *ArtifactRepository_All_Call

+ func (_c *ArtifactRepository_All_Call) RunAndReturn(run func() ([]models.Artifact, error)) *ArtifactRepository_All_Call

+ type ArtifactRepository_Begin_Call struct

+ func (_c *ArtifactRepository_Begin_Call) Return(v core.DB) *ArtifactRepository_Begin_Call

+ func (_c *ArtifactRepository_Begin_Call) Run(run func()) *ArtifactRepository_Begin_Call

+ func (_c *ArtifactRepository_Begin_Call) RunAndReturn(run func() core.DB) *ArtifactRepository_Begin_Call

+ type ArtifactRepository_CreateBatch_Call struct

+ func (_c *ArtifactRepository_CreateBatch_Call) Return(err error) *ArtifactRepository_CreateBatch_Call

+ func (_c *ArtifactRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.Artifact)) *ArtifactRepository_CreateBatch_Call

+ func (_c *ArtifactRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Artifact) error) *ArtifactRepository_CreateBatch_Call

+ type ArtifactRepository_Create_Call struct

+ func (_c *ArtifactRepository_Create_Call) Return(err error) *ArtifactRepository_Create_Call

+ func (_c *ArtifactRepository_Create_Call) Run(run func(tx core.DB, t *models.Artifact)) *ArtifactRepository_Create_Call

+ func (_c *ArtifactRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.Artifact) error) *ArtifactRepository_Create_Call

+ type ArtifactRepository_DeleteArtifact_Call struct

+ func (_c *ArtifactRepository_DeleteArtifact_Call) Return(err error) *ArtifactRepository_DeleteArtifact_Call

+ func (_c *ArtifactRepository_DeleteArtifact_Call) Run(run func(assetID uuid.UUID, assetVersionName string, artifactName string)) *ArtifactRepository_DeleteArtifact_Call

+ func (_c *ArtifactRepository_DeleteArtifact_Call) RunAndReturn(...) *ArtifactRepository_DeleteArtifact_Call

+ type ArtifactRepository_DeleteBatch_Call struct

+ func (_c *ArtifactRepository_DeleteBatch_Call) Return(err error) *ArtifactRepository_DeleteBatch_Call

+ func (_c *ArtifactRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.Artifact)) *ArtifactRepository_DeleteBatch_Call

+ func (_c *ArtifactRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.Artifact) error) *ArtifactRepository_DeleteBatch_Call

+ type ArtifactRepository_Delete_Call struct

+ func (_c *ArtifactRepository_Delete_Call) Return(err error) *ArtifactRepository_Delete_Call

+ func (_c *ArtifactRepository_Delete_Call) Run(run func(tx core.DB, id string)) *ArtifactRepository_Delete_Call

+ func (_c *ArtifactRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *ArtifactRepository_Delete_Call

+ type ArtifactRepository_Expecter struct

+ func (_e *ArtifactRepository_Expecter) Activate(tx interface{}, id interface{}) *ArtifactRepository_Activate_Call

+ func (_e *ArtifactRepository_Expecter) All() *ArtifactRepository_All_Call

+ func (_e *ArtifactRepository_Expecter) Begin() *ArtifactRepository_Begin_Call

+ func (_e *ArtifactRepository_Expecter) Create(tx interface{}, t interface{}) *ArtifactRepository_Create_Call

+ func (_e *ArtifactRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *ArtifactRepository_CreateBatch_Call

+ func (_e *ArtifactRepository_Expecter) Delete(tx interface{}, id interface{}) *ArtifactRepository_Delete_Call

+ func (_e *ArtifactRepository_Expecter) DeleteArtifact(assetID interface{}, assetVersionName interface{}, artifactName interface{}) *ArtifactRepository_DeleteArtifact_Call

+ func (_e *ArtifactRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *ArtifactRepository_DeleteBatch_Call

+ func (_e *ArtifactRepository_Expecter) GetByAssetIDAndAssetVersionName(assetID interface{}, assetVersionName interface{}) *ArtifactRepository_GetByAssetIDAndAssetVersionName_Call

+ func (_e *ArtifactRepository_Expecter) GetDB(tx interface{}) *ArtifactRepository_GetDB_Call

+ func (_e *ArtifactRepository_Expecter) List(ids interface{}) *ArtifactRepository_List_Call

+ func (_e *ArtifactRepository_Expecter) Read(id interface{}) *ArtifactRepository_Read_Call

+ func (_e *ArtifactRepository_Expecter) ReadArtifact(name interface{}, assetVersionName interface{}, assetID interface{}) *ArtifactRepository_ReadArtifact_Call

+ func (_e *ArtifactRepository_Expecter) Save(tx interface{}, t interface{}) *ArtifactRepository_Save_Call

+ func (_e *ArtifactRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *ArtifactRepository_SaveBatch_Call

+ func (_e *ArtifactRepository_Expecter) Transaction(fn interface{}) *ArtifactRepository_Transaction_Call

+ func (_e *ArtifactRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *ArtifactRepository_Upsert_Call

+ type ArtifactRepository_GetByAssetIDAndAssetVersionName_Call struct

+ func (_c *ArtifactRepository_GetByAssetIDAndAssetVersionName_Call) Return(artifacts []models.Artifact, err error) *ArtifactRepository_GetByAssetIDAndAssetVersionName_Call

+ func (_c *ArtifactRepository_GetByAssetIDAndAssetVersionName_Call) Run(run func(assetID uuid.UUID, assetVersionName string)) *ArtifactRepository_GetByAssetIDAndAssetVersionName_Call

+ func (_c *ArtifactRepository_GetByAssetIDAndAssetVersionName_Call) RunAndReturn(...) *ArtifactRepository_GetByAssetIDAndAssetVersionName_Call

+ type ArtifactRepository_GetDB_Call struct

+ func (_c *ArtifactRepository_GetDB_Call) Return(v core.DB) *ArtifactRepository_GetDB_Call

+ func (_c *ArtifactRepository_GetDB_Call) Run(run func(tx core.DB)) *ArtifactRepository_GetDB_Call

+ func (_c *ArtifactRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *ArtifactRepository_GetDB_Call

+ type ArtifactRepository_List_Call struct

+ func (_c *ArtifactRepository_List_Call) Return(artifacts []models.Artifact, err error) *ArtifactRepository_List_Call

+ func (_c *ArtifactRepository_List_Call) Run(run func(ids []string)) *ArtifactRepository_List_Call

+ func (_c *ArtifactRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.Artifact, error)) *ArtifactRepository_List_Call

+ type ArtifactRepository_ReadArtifact_Call struct

+ func (_c *ArtifactRepository_ReadArtifact_Call) Return(artifact models.Artifact, err error) *ArtifactRepository_ReadArtifact_Call

+ func (_c *ArtifactRepository_ReadArtifact_Call) Run(run func(name string, assetVersionName string, assetID uuid.UUID)) *ArtifactRepository_ReadArtifact_Call

+ func (_c *ArtifactRepository_ReadArtifact_Call) RunAndReturn(...) *ArtifactRepository_ReadArtifact_Call

+ type ArtifactRepository_Read_Call struct

+ func (_c *ArtifactRepository_Read_Call) Return(artifact models.Artifact, err error) *ArtifactRepository_Read_Call

+ func (_c *ArtifactRepository_Read_Call) Run(run func(id string)) *ArtifactRepository_Read_Call

+ func (_c *ArtifactRepository_Read_Call) RunAndReturn(run func(id string) (models.Artifact, error)) *ArtifactRepository_Read_Call

+ type ArtifactRepository_SaveBatch_Call struct

+ func (_c *ArtifactRepository_SaveBatch_Call) Return(err error) *ArtifactRepository_SaveBatch_Call

+ func (_c *ArtifactRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.Artifact)) *ArtifactRepository_SaveBatch_Call

+ func (_c *ArtifactRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Artifact) error) *ArtifactRepository_SaveBatch_Call

+ type ArtifactRepository_Save_Call struct

+ func (_c *ArtifactRepository_Save_Call) Return(err error) *ArtifactRepository_Save_Call

+ func (_c *ArtifactRepository_Save_Call) Run(run func(tx core.DB, t *models.Artifact)) *ArtifactRepository_Save_Call

+ func (_c *ArtifactRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.Artifact) error) *ArtifactRepository_Save_Call

+ type ArtifactRepository_Transaction_Call struct

+ func (_c *ArtifactRepository_Transaction_Call) Return(err error) *ArtifactRepository_Transaction_Call

+ func (_c *ArtifactRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *ArtifactRepository_Transaction_Call

+ func (_c *ArtifactRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *ArtifactRepository_Transaction_Call

+ type ArtifactRepository_Upsert_Call struct

+ func (_c *ArtifactRepository_Upsert_Call) Return(err error) *ArtifactRepository_Upsert_Call

+ func (_c *ArtifactRepository_Upsert_Call) Run(...) *ArtifactRepository_Upsert_Call

+ func (_c *ArtifactRepository_Upsert_Call) RunAndReturn(...) *ArtifactRepository_Upsert_Call

+ type ArtifactRiskHistoryRepository struct

+ func NewArtifactRiskHistoryRepository(t interface{ ... }) *ArtifactRiskHistoryRepository

+ func (_m *ArtifactRiskHistoryRepository) EXPECT() *ArtifactRiskHistoryRepository_Expecter

+ func (_mock *ArtifactRiskHistoryRepository) GetRiskHistory(artifactName *string, assetVersionName string, assetID uuid.UUID, ...) ([]models.ArtifactRiskHistory, error)

+ func (_mock *ArtifactRiskHistoryRepository) GetRiskHistoryByRelease(releaseID uuid.UUID, start time.Time, end time.Time) ([]models.ArtifactRiskHistory, error)

+ func (_mock *ArtifactRiskHistoryRepository) UpdateRiskAggregation(assetRisk *models.ArtifactRiskHistory) error

+ type ArtifactRiskHistoryRepository_Expecter struct

+ func (_e *ArtifactRiskHistoryRepository_Expecter) GetRiskHistory(artifactName interface{}, assetVersionName interface{}, assetID interface{}, ...) *ArtifactRiskHistoryRepository_GetRiskHistory_Call

+ func (_e *ArtifactRiskHistoryRepository_Expecter) GetRiskHistoryByRelease(releaseID interface{}, start interface{}, end interface{}) *ArtifactRiskHistoryRepository_GetRiskHistoryByRelease_Call

+ func (_e *ArtifactRiskHistoryRepository_Expecter) UpdateRiskAggregation(assetRisk interface{}) *ArtifactRiskHistoryRepository_UpdateRiskAggregation_Call

+ type ArtifactRiskHistoryRepository_GetRiskHistoryByRelease_Call struct

+ func (_c *ArtifactRiskHistoryRepository_GetRiskHistoryByRelease_Call) Return(artifactRiskHistorys []models.ArtifactRiskHistory, err error) *ArtifactRiskHistoryRepository_GetRiskHistoryByRelease_Call

+ func (_c *ArtifactRiskHistoryRepository_GetRiskHistoryByRelease_Call) Run(run func(releaseID uuid.UUID, start time.Time, end time.Time)) *ArtifactRiskHistoryRepository_GetRiskHistoryByRelease_Call

+ func (_c *ArtifactRiskHistoryRepository_GetRiskHistoryByRelease_Call) RunAndReturn(...) *ArtifactRiskHistoryRepository_GetRiskHistoryByRelease_Call

+ type ArtifactRiskHistoryRepository_GetRiskHistory_Call struct

+ func (_c *ArtifactRiskHistoryRepository_GetRiskHistory_Call) Return(artifactRiskHistorys []models.ArtifactRiskHistory, err error) *ArtifactRiskHistoryRepository_GetRiskHistory_Call

+ func (_c *ArtifactRiskHistoryRepository_GetRiskHistory_Call) Run(...) *ArtifactRiskHistoryRepository_GetRiskHistory_Call

+ func (_c *ArtifactRiskHistoryRepository_GetRiskHistory_Call) RunAndReturn(...) *ArtifactRiskHistoryRepository_GetRiskHistory_Call

+ type ArtifactRiskHistoryRepository_UpdateRiskAggregation_Call struct

+ func (_c *ArtifactRiskHistoryRepository_UpdateRiskAggregation_Call) Return(err error) *ArtifactRiskHistoryRepository_UpdateRiskAggregation_Call

+ func (_c *ArtifactRiskHistoryRepository_UpdateRiskAggregation_Call) Run(run func(assetRisk *models.ArtifactRiskHistory)) *ArtifactRiskHistoryRepository_UpdateRiskAggregation_Call

+ func (_c *ArtifactRiskHistoryRepository_UpdateRiskAggregation_Call) RunAndReturn(run func(assetRisk *models.ArtifactRiskHistory) error) *ArtifactRiskHistoryRepository_UpdateRiskAggregation_Call

+ type ArtifactService struct

+ func NewArtifactService(t interface{ ... }) *ArtifactService

+ func (_m *ArtifactService) EXPECT() *ArtifactService_Expecter

+ func (_mock *ArtifactService) DeleteArtifact(assetID uuid.UUID, assetVersionName string, artifactName string) error

+ func (_mock *ArtifactService) GetArtifactNamesByAssetIDAndAssetVersionName(assetID uuid.UUID, assetVersionName string) ([]models.Artifact, error)

+ func (_mock *ArtifactService) SaveArtifact(artifact *models.Artifact) error

+ type ArtifactService_DeleteArtifact_Call struct

+ func (_c *ArtifactService_DeleteArtifact_Call) Return(err error) *ArtifactService_DeleteArtifact_Call

+ func (_c *ArtifactService_DeleteArtifact_Call) Run(run func(assetID uuid.UUID, assetVersionName string, artifactName string)) *ArtifactService_DeleteArtifact_Call

+ func (_c *ArtifactService_DeleteArtifact_Call) RunAndReturn(...) *ArtifactService_DeleteArtifact_Call

+ type ArtifactService_Expecter struct

+ func (_e *ArtifactService_Expecter) DeleteArtifact(assetID interface{}, assetVersionName interface{}, artifactName interface{}) *ArtifactService_DeleteArtifact_Call

+ func (_e *ArtifactService_Expecter) GetArtifactNamesByAssetIDAndAssetVersionName(assetID interface{}, assetVersionName interface{}) *ArtifactService_GetArtifactNamesByAssetIDAndAssetVersionName_Call

+ func (_e *ArtifactService_Expecter) SaveArtifact(artifact interface{}) *ArtifactService_SaveArtifact_Call

+ type ArtifactService_GetArtifactNamesByAssetIDAndAssetVersionName_Call struct

+ func (_c *ArtifactService_GetArtifactNamesByAssetIDAndAssetVersionName_Call) Return(artifacts []models.Artifact, err error) *ArtifactService_GetArtifactNamesByAssetIDAndAssetVersionName_Call

+ func (_c *ArtifactService_GetArtifactNamesByAssetIDAndAssetVersionName_Call) Run(run func(assetID uuid.UUID, assetVersionName string)) *ArtifactService_GetArtifactNamesByAssetIDAndAssetVersionName_Call

+ func (_c *ArtifactService_GetArtifactNamesByAssetIDAndAssetVersionName_Call) RunAndReturn(...) *ArtifactService_GetArtifactNamesByAssetIDAndAssetVersionName_Call

+ type ArtifactService_SaveArtifact_Call struct

+ func (_c *ArtifactService_SaveArtifact_Call) Return(err error) *ArtifactService_SaveArtifact_Call

+ func (_c *ArtifactService_SaveArtifact_Call) Run(run func(artifact *models.Artifact)) *ArtifactService_SaveArtifact_Call

+ func (_c *ArtifactService_SaveArtifact_Call) RunAndReturn(run func(artifact *models.Artifact) error) *ArtifactService_SaveArtifact_Call

type AssetRepository

+ func (_mock *AssetRepository) All() ([]models.Asset, error)

+ func (_mock *AssetRepository) DeleteBatch(tx core.DB, ids []models.Asset) error

+ func (_mock *AssetRepository) FindAssetByExternalProviderID(externalEntityProviderID string, externalEntityID string) (*models.Asset, error)

+ func (_mock *AssetRepository) GetAllAssetsFromDB() ([]models.Asset, error)

+ func (_mock *AssetRepository) GetAssetIDByBadgeSecret(badgeSecret uuid.UUID) (models.Asset, error)

+ func (_mock *AssetRepository) GetByOrgID(organizationID uuid.UUID) ([]models.Asset, error)

+ func (_mock *AssetRepository) GetFQNByID(id uuid.UUID) (string, error)

+ func (_mock *AssetRepository) ReadWithAssetVersions(assetID uuid.UUID) (models.Asset, error)

+ func (_mock *AssetRepository) Upsert(t *[]*models.Asset, conflictingColumns []clause.Column, updateOnly []string) error

+ type AssetRepository_All_Call struct

+ func (_c *AssetRepository_All_Call) Return(assets []models.Asset, err error) *AssetRepository_All_Call

+ func (_c *AssetRepository_All_Call) Run(run func()) *AssetRepository_All_Call

+ func (_c *AssetRepository_All_Call) RunAndReturn(run func() ([]models.Asset, error)) *AssetRepository_All_Call

+ type AssetRepository_DeleteBatch_Call struct

+ func (_c *AssetRepository_DeleteBatch_Call) Return(err error) *AssetRepository_DeleteBatch_Call

+ func (_c *AssetRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.Asset)) *AssetRepository_DeleteBatch_Call

+ func (_c *AssetRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.Asset) error) *AssetRepository_DeleteBatch_Call

type AssetRepository_Expecter

+ func (_e *AssetRepository_Expecter) All() *AssetRepository_All_Call

+ func (_e *AssetRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *AssetRepository_DeleteBatch_Call

+ func (_e *AssetRepository_Expecter) FindAssetByExternalProviderID(externalEntityProviderID interface{}, externalEntityID interface{}) *AssetRepository_FindAssetByExternalProviderID_Call

+ func (_e *AssetRepository_Expecter) GetAllAssetsFromDB() *AssetRepository_GetAllAssetsFromDB_Call

+ func (_e *AssetRepository_Expecter) GetAssetIDByBadgeSecret(badgeSecret interface{}) *AssetRepository_GetAssetIDByBadgeSecret_Call

+ func (_e *AssetRepository_Expecter) GetByOrgID(organizationID interface{}) *AssetRepository_GetByOrgID_Call

+ func (_e *AssetRepository_Expecter) GetFQNByID(id interface{}) *AssetRepository_GetFQNByID_Call

+ func (_e *AssetRepository_Expecter) ReadWithAssetVersions(assetID interface{}) *AssetRepository_ReadWithAssetVersions_Call

+ func (_e *AssetRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *AssetRepository_Upsert_Call

+ type AssetRepository_FindAssetByExternalProviderID_Call struct

+ func (_c *AssetRepository_FindAssetByExternalProviderID_Call) Return(asset *models.Asset, err error) *AssetRepository_FindAssetByExternalProviderID_Call

+ func (_c *AssetRepository_FindAssetByExternalProviderID_Call) Run(run func(externalEntityProviderID string, externalEntityID string)) *AssetRepository_FindAssetByExternalProviderID_Call

+ func (_c *AssetRepository_FindAssetByExternalProviderID_Call) RunAndReturn(...) *AssetRepository_FindAssetByExternalProviderID_Call

+ type AssetRepository_GetAllAssetsFromDB_Call struct

+ func (_c *AssetRepository_GetAllAssetsFromDB_Call) Return(assets []models.Asset, err error) *AssetRepository_GetAllAssetsFromDB_Call

+ func (_c *AssetRepository_GetAllAssetsFromDB_Call) Run(run func()) *AssetRepository_GetAllAssetsFromDB_Call

+ func (_c *AssetRepository_GetAllAssetsFromDB_Call) RunAndReturn(run func() ([]models.Asset, error)) *AssetRepository_GetAllAssetsFromDB_Call

+ type AssetRepository_GetAssetIDByBadgeSecret_Call struct

+ func (_c *AssetRepository_GetAssetIDByBadgeSecret_Call) Return(asset models.Asset, err error) *AssetRepository_GetAssetIDByBadgeSecret_Call

+ func (_c *AssetRepository_GetAssetIDByBadgeSecret_Call) Run(run func(badgeSecret uuid.UUID)) *AssetRepository_GetAssetIDByBadgeSecret_Call

+ func (_c *AssetRepository_GetAssetIDByBadgeSecret_Call) RunAndReturn(run func(badgeSecret uuid.UUID) (models.Asset, error)) *AssetRepository_GetAssetIDByBadgeSecret_Call

+ type AssetRepository_GetByOrgID_Call struct

+ func (_c *AssetRepository_GetByOrgID_Call) Return(assets []models.Asset, err error) *AssetRepository_GetByOrgID_Call

+ func (_c *AssetRepository_GetByOrgID_Call) Run(run func(organizationID uuid.UUID)) *AssetRepository_GetByOrgID_Call

+ func (_c *AssetRepository_GetByOrgID_Call) RunAndReturn(run func(organizationID uuid.UUID) ([]models.Asset, error)) *AssetRepository_GetByOrgID_Call

+ type AssetRepository_GetFQNByID_Call struct

+ func (_c *AssetRepository_GetFQNByID_Call) Return(s string, err error) *AssetRepository_GetFQNByID_Call

+ func (_c *AssetRepository_GetFQNByID_Call) Run(run func(id uuid.UUID)) *AssetRepository_GetFQNByID_Call

+ func (_c *AssetRepository_GetFQNByID_Call) RunAndReturn(run func(id uuid.UUID) (string, error)) *AssetRepository_GetFQNByID_Call

+ type AssetRepository_ReadWithAssetVersions_Call struct

+ func (_c *AssetRepository_ReadWithAssetVersions_Call) Return(asset models.Asset, err error) *AssetRepository_ReadWithAssetVersions_Call

+ func (_c *AssetRepository_ReadWithAssetVersions_Call) Run(run func(assetID uuid.UUID)) *AssetRepository_ReadWithAssetVersions_Call

+ func (_c *AssetRepository_ReadWithAssetVersions_Call) RunAndReturn(run func(assetID uuid.UUID) (models.Asset, error)) *AssetRepository_ReadWithAssetVersions_Call

+ type AssetRepository_Upsert_Call struct

+ func (_c *AssetRepository_Upsert_Call) Return(err error) *AssetRepository_Upsert_Call

+ func (_c *AssetRepository_Upsert_Call) Run(...) *AssetRepository_Upsert_Call

+ func (_c *AssetRepository_Upsert_Call) RunAndReturn(...) *AssetRepository_Upsert_Call

+ type AssetService struct

+ func NewAssetService(t interface{ ... }) *AssetService

+ func (_m *AssetService) EXPECT() *AssetService_Expecter

+ func (_mock *AssetService) CreateAsset(asset models.Asset) (*models.Asset, error)

+ func (_mock *AssetService) GetCVSSBadgeSVG(results []models.ArtifactRiskHistory) string

+ func (_mock *AssetService) UpdateAssetRequirements(asset models.Asset, responsible string, justification string) error

+ type AssetService_CreateAsset_Call struct

+ func (_c *AssetService_CreateAsset_Call) Return(asset1 *models.Asset, err error) *AssetService_CreateAsset_Call

+ func (_c *AssetService_CreateAsset_Call) Run(run func(asset models.Asset)) *AssetService_CreateAsset_Call

+ func (_c *AssetService_CreateAsset_Call) RunAndReturn(run func(asset models.Asset) (*models.Asset, error)) *AssetService_CreateAsset_Call

+ type AssetService_Expecter struct

+ func (_e *AssetService_Expecter) CreateAsset(asset interface{}) *AssetService_CreateAsset_Call

+ func (_e *AssetService_Expecter) GetCVSSBadgeSVG(results interface{}) *AssetService_GetCVSSBadgeSVG_Call

+ func (_e *AssetService_Expecter) UpdateAssetRequirements(asset interface{}, responsible interface{}, justification interface{}) *AssetService_UpdateAssetRequirements_Call

+ type AssetService_GetCVSSBadgeSVG_Call struct

+ func (_c *AssetService_GetCVSSBadgeSVG_Call) Return(s string) *AssetService_GetCVSSBadgeSVG_Call

+ func (_c *AssetService_GetCVSSBadgeSVG_Call) Run(run func(results []models.ArtifactRiskHistory)) *AssetService_GetCVSSBadgeSVG_Call

+ func (_c *AssetService_GetCVSSBadgeSVG_Call) RunAndReturn(run func(results []models.ArtifactRiskHistory) string) *AssetService_GetCVSSBadgeSVG_Call

+ type AssetService_UpdateAssetRequirements_Call struct

+ func (_c *AssetService_UpdateAssetRequirements_Call) Return(err error) *AssetService_UpdateAssetRequirements_Call

+ func (_c *AssetService_UpdateAssetRequirements_Call) Run(run func(asset models.Asset, responsible string, justification string)) *AssetService_UpdateAssetRequirements_Call

+ func (_c *AssetService_UpdateAssetRequirements_Call) RunAndReturn(run func(asset models.Asset, responsible string, justification string) error) *AssetService_UpdateAssetRequirements_Call

+ type AssetVersionRepository struct

+ func NewAssetVersionRepository(t interface{ ... }) *AssetVersionRepository

+ func (_m *AssetVersionRepository) EXPECT() *AssetVersionRepository_Expecter

+ func (_mock *AssetVersionRepository) All() ([]models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) Delete(tx core.DB, assetVersion *models.AssetVersion) error

+ func (_mock *AssetVersionRepository) FindOrCreate(assetVersionName string, assetID uuid.UUID, tag bool, ...) (models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) GetAllAssetsVersionFromDBByAssetID(tx core.DB, assetID uuid.UUID) ([]models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) GetDB(v core.DB) core.DB

+ func (_mock *AssetVersionRepository) GetDefaultAssetVersion(assetID uuid.UUID) (models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) GetDefaultAssetVersionsByProjectID(projectID uuid.UUID) ([]models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) GetDefaultAssetVersionsByProjectIDs(projectIDs []uuid.UUID) ([]models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) Read(assetVersionName string, assetID uuid.UUID) (models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) ReadBySlug(assetID uuid.UUID, slug string) (models.AssetVersion, error)

+ func (_mock *AssetVersionRepository) Save(tx core.DB, assetVersion *models.AssetVersion) error

+ type AssetVersionRepository_All_Call struct

+ func (_c *AssetVersionRepository_All_Call) Return(assetVersions []models.AssetVersion, err error) *AssetVersionRepository_All_Call

+ func (_c *AssetVersionRepository_All_Call) Run(run func()) *AssetVersionRepository_All_Call

+ func (_c *AssetVersionRepository_All_Call) RunAndReturn(run func() ([]models.AssetVersion, error)) *AssetVersionRepository_All_Call

+ type AssetVersionRepository_Delete_Call struct

+ func (_c *AssetVersionRepository_Delete_Call) Return(err error) *AssetVersionRepository_Delete_Call

+ func (_c *AssetVersionRepository_Delete_Call) Run(run func(tx core.DB, assetVersion *models.AssetVersion)) *AssetVersionRepository_Delete_Call

+ func (_c *AssetVersionRepository_Delete_Call) RunAndReturn(run func(tx core.DB, assetVersion *models.AssetVersion) error) *AssetVersionRepository_Delete_Call

+ type AssetVersionRepository_Expecter struct

+ func (_e *AssetVersionRepository_Expecter) All() *AssetVersionRepository_All_Call

+ func (_e *AssetVersionRepository_Expecter) Delete(tx interface{}, assetVersion interface{}) *AssetVersionRepository_Delete_Call

+ func (_e *AssetVersionRepository_Expecter) FindOrCreate(assetVersionName interface{}, assetID interface{}, tag interface{}, ...) *AssetVersionRepository_FindOrCreate_Call

+ func (_e *AssetVersionRepository_Expecter) GetAllAssetsVersionFromDBByAssetID(tx interface{}, assetID interface{}) *AssetVersionRepository_GetAllAssetsVersionFromDBByAssetID_Call

+ func (_e *AssetVersionRepository_Expecter) GetDB(v interface{}) *AssetVersionRepository_GetDB_Call

+ func (_e *AssetVersionRepository_Expecter) GetDefaultAssetVersion(assetID interface{}) *AssetVersionRepository_GetDefaultAssetVersion_Call

+ func (_e *AssetVersionRepository_Expecter) GetDefaultAssetVersionsByProjectID(projectID interface{}) *AssetVersionRepository_GetDefaultAssetVersionsByProjectID_Call

+ func (_e *AssetVersionRepository_Expecter) GetDefaultAssetVersionsByProjectIDs(projectIDs interface{}) *AssetVersionRepository_GetDefaultAssetVersionsByProjectIDs_Call

+ func (_e *AssetVersionRepository_Expecter) Read(assetVersionName interface{}, assetID interface{}) *AssetVersionRepository_Read_Call

+ func (_e *AssetVersionRepository_Expecter) ReadBySlug(assetID interface{}, slug interface{}) *AssetVersionRepository_ReadBySlug_Call

+ func (_e *AssetVersionRepository_Expecter) Save(tx interface{}, assetVersion interface{}) *AssetVersionRepository_Save_Call

+ type AssetVersionRepository_FindOrCreate_Call struct

+ func (_c *AssetVersionRepository_FindOrCreate_Call) Return(assetVersion models.AssetVersion, err error) *AssetVersionRepository_FindOrCreate_Call

+ func (_c *AssetVersionRepository_FindOrCreate_Call) Run(run func(assetVersionName string, assetID uuid.UUID, tag bool, ...)) *AssetVersionRepository_FindOrCreate_Call

+ func (_c *AssetVersionRepository_FindOrCreate_Call) RunAndReturn(...) *AssetVersionRepository_FindOrCreate_Call

+ type AssetVersionRepository_GetAllAssetsVersionFromDBByAssetID_Call struct

+ func (_c *AssetVersionRepository_GetAllAssetsVersionFromDBByAssetID_Call) Return(assetVersions []models.AssetVersion, err error) *AssetVersionRepository_GetAllAssetsVersionFromDBByAssetID_Call

+ func (_c *AssetVersionRepository_GetAllAssetsVersionFromDBByAssetID_Call) Run(run func(tx core.DB, assetID uuid.UUID)) *AssetVersionRepository_GetAllAssetsVersionFromDBByAssetID_Call

+ func (_c *AssetVersionRepository_GetAllAssetsVersionFromDBByAssetID_Call) RunAndReturn(run func(tx core.DB, assetID uuid.UUID) ([]models.AssetVersion, error)) *AssetVersionRepository_GetAllAssetsVersionFromDBByAssetID_Call

+ type AssetVersionRepository_GetDB_Call struct

+ func (_c *AssetVersionRepository_GetDB_Call) Return(v1 core.DB) *AssetVersionRepository_GetDB_Call

+ func (_c *AssetVersionRepository_GetDB_Call) Run(run func(v core.DB)) *AssetVersionRepository_GetDB_Call

+ func (_c *AssetVersionRepository_GetDB_Call) RunAndReturn(run func(v core.DB) core.DB) *AssetVersionRepository_GetDB_Call

+ type AssetVersionRepository_GetDefaultAssetVersion_Call struct

+ func (_c *AssetVersionRepository_GetDefaultAssetVersion_Call) Return(assetVersion models.AssetVersion, err error) *AssetVersionRepository_GetDefaultAssetVersion_Call

+ func (_c *AssetVersionRepository_GetDefaultAssetVersion_Call) Run(run func(assetID uuid.UUID)) *AssetVersionRepository_GetDefaultAssetVersion_Call

+ func (_c *AssetVersionRepository_GetDefaultAssetVersion_Call) RunAndReturn(run func(assetID uuid.UUID) (models.AssetVersion, error)) *AssetVersionRepository_GetDefaultAssetVersion_Call

+ type AssetVersionRepository_GetDefaultAssetVersionsByProjectID_Call struct

+ func (_c *AssetVersionRepository_GetDefaultAssetVersionsByProjectID_Call) Return(assetVersions []models.AssetVersion, err error) *AssetVersionRepository_GetDefaultAssetVersionsByProjectID_Call

+ func (_c *AssetVersionRepository_GetDefaultAssetVersionsByProjectID_Call) Run(run func(projectID uuid.UUID)) *AssetVersionRepository_GetDefaultAssetVersionsByProjectID_Call

+ func (_c *AssetVersionRepository_GetDefaultAssetVersionsByProjectID_Call) RunAndReturn(run func(projectID uuid.UUID) ([]models.AssetVersion, error)) *AssetVersionRepository_GetDefaultAssetVersionsByProjectID_Call

+ type AssetVersionRepository_GetDefaultAssetVersionsByProjectIDs_Call struct

+ func (_c *AssetVersionRepository_GetDefaultAssetVersionsByProjectIDs_Call) Return(assetVersions []models.AssetVersion, err error) *AssetVersionRepository_GetDefaultAssetVersionsByProjectIDs_Call

+ func (_c *AssetVersionRepository_GetDefaultAssetVersionsByProjectIDs_Call) Run(run func(projectIDs []uuid.UUID)) *AssetVersionRepository_GetDefaultAssetVersionsByProjectIDs_Call

+ func (_c *AssetVersionRepository_GetDefaultAssetVersionsByProjectIDs_Call) RunAndReturn(run func(projectIDs []uuid.UUID) ([]models.AssetVersion, error)) *AssetVersionRepository_GetDefaultAssetVersionsByProjectIDs_Call

+ type AssetVersionRepository_ReadBySlug_Call struct

+ func (_c *AssetVersionRepository_ReadBySlug_Call) Return(assetVersion models.AssetVersion, err error) *AssetVersionRepository_ReadBySlug_Call

+ func (_c *AssetVersionRepository_ReadBySlug_Call) Run(run func(assetID uuid.UUID, slug string)) *AssetVersionRepository_ReadBySlug_Call

+ func (_c *AssetVersionRepository_ReadBySlug_Call) RunAndReturn(run func(assetID uuid.UUID, slug string) (models.AssetVersion, error)) *AssetVersionRepository_ReadBySlug_Call

+ type AssetVersionRepository_Read_Call struct

+ func (_c *AssetVersionRepository_Read_Call) Return(assetVersion models.AssetVersion, err error) *AssetVersionRepository_Read_Call

+ func (_c *AssetVersionRepository_Read_Call) Run(run func(assetVersionName string, assetID uuid.UUID)) *AssetVersionRepository_Read_Call

+ func (_c *AssetVersionRepository_Read_Call) RunAndReturn(...) *AssetVersionRepository_Read_Call

+ type AssetVersionRepository_Save_Call struct

+ func (_c *AssetVersionRepository_Save_Call) Return(err error) *AssetVersionRepository_Save_Call

+ func (_c *AssetVersionRepository_Save_Call) Run(run func(tx core.DB, assetVersion *models.AssetVersion)) *AssetVersionRepository_Save_Call

+ func (_c *AssetVersionRepository_Save_Call) RunAndReturn(run func(tx core.DB, assetVersion *models.AssetVersion) error) *AssetVersionRepository_Save_Call

+ type AssetVersionService struct

+ func NewAssetVersionService(t interface{ ... }) *AssetVersionService

+ func (_m *AssetVersionService) EXPECT() *AssetVersionService_Expecter

+ func (_mock *AssetVersionService) BuildOpenVeX(asset models.Asset, assetVersion models.AssetVersion, organizationSlug string, ...) vex.VEX

+ func (_mock *AssetVersionService) BuildSBOM(assetVersion models.AssetVersion, artifactName string, version string, ...) (*cyclonedx.BOM, error)

+ func (_mock *AssetVersionService) BuildVeX(asset models.Asset, assetVersion models.AssetVersion, orgName string, ...) *cyclonedx.BOM

+ func (_mock *AssetVersionService) GetAssetVersionsByAssetID(assetID uuid.UUID) ([]models.AssetVersion, error)

+ func (_mock *AssetVersionService) HandleFirstPartyVulnResult(org models.Org, project models.Project, asset models.Asset, ...) ([]models.FirstPartyVuln, []models.FirstPartyVuln, []models.FirstPartyVuln, ...)

+ func (_mock *AssetVersionService) HandleScanResult(org models.Org, project models.Project, asset models.Asset, ...) ([]models.DependencyVuln, []models.DependencyVuln, []models.DependencyVuln, ...)

+ func (_mock *AssetVersionService) UpdateSBOM(org models.Org, project models.Project, asset models.Asset, ...) error

+ type AssetVersionService_BuildOpenVeX_Call struct

+ func (_c *AssetVersionService_BuildOpenVeX_Call) Return(vEX vex.VEX) *AssetVersionService_BuildOpenVeX_Call

+ func (_c *AssetVersionService_BuildOpenVeX_Call) Run(...) *AssetVersionService_BuildOpenVeX_Call

+ func (_c *AssetVersionService_BuildOpenVeX_Call) RunAndReturn(...) *AssetVersionService_BuildOpenVeX_Call

+ type AssetVersionService_BuildSBOM_Call struct

+ func (_c *AssetVersionService_BuildSBOM_Call) Return(bOM *cyclonedx.BOM, err error) *AssetVersionService_BuildSBOM_Call

+ func (_c *AssetVersionService_BuildSBOM_Call) Run(...) *AssetVersionService_BuildSBOM_Call

+ func (_c *AssetVersionService_BuildSBOM_Call) RunAndReturn(...) *AssetVersionService_BuildSBOM_Call

+ type AssetVersionService_BuildVeX_Call struct

+ func (_c *AssetVersionService_BuildVeX_Call) Return(bOM *cyclonedx.BOM) *AssetVersionService_BuildVeX_Call

+ func (_c *AssetVersionService_BuildVeX_Call) Run(...) *AssetVersionService_BuildVeX_Call

+ func (_c *AssetVersionService_BuildVeX_Call) RunAndReturn(...) *AssetVersionService_BuildVeX_Call

+ type AssetVersionService_Expecter struct

+ func (_e *AssetVersionService_Expecter) BuildOpenVeX(asset interface{}, assetVersion interface{}, organizationSlug interface{}, ...) *AssetVersionService_BuildOpenVeX_Call

+ func (_e *AssetVersionService_Expecter) BuildSBOM(assetVersion interface{}, artifactName interface{}, version interface{}, ...) *AssetVersionService_BuildSBOM_Call

+ func (_e *AssetVersionService_Expecter) BuildVeX(asset interface{}, assetVersion interface{}, orgName interface{}, ...) *AssetVersionService_BuildVeX_Call

+ func (_e *AssetVersionService_Expecter) GetAssetVersionsByAssetID(assetID interface{}) *AssetVersionService_GetAssetVersionsByAssetID_Call

+ func (_e *AssetVersionService_Expecter) HandleFirstPartyVulnResult(org interface{}, project interface{}, asset interface{}, ...) *AssetVersionService_HandleFirstPartyVulnResult_Call

+ func (_e *AssetVersionService_Expecter) HandleScanResult(org interface{}, project interface{}, asset interface{}, ...) *AssetVersionService_HandleScanResult_Call

+ func (_e *AssetVersionService_Expecter) UpdateSBOM(org interface{}, project interface{}, asset interface{}, ...) *AssetVersionService_UpdateSBOM_Call

+ type AssetVersionService_GetAssetVersionsByAssetID_Call struct

+ func (_c *AssetVersionService_GetAssetVersionsByAssetID_Call) Return(assetVersions []models.AssetVersion, err error) *AssetVersionService_GetAssetVersionsByAssetID_Call

+ func (_c *AssetVersionService_GetAssetVersionsByAssetID_Call) Run(run func(assetID uuid.UUID)) *AssetVersionService_GetAssetVersionsByAssetID_Call

+ func (_c *AssetVersionService_GetAssetVersionsByAssetID_Call) RunAndReturn(run func(assetID uuid.UUID) ([]models.AssetVersion, error)) *AssetVersionService_GetAssetVersionsByAssetID_Call

+ type AssetVersionService_HandleFirstPartyVulnResult_Call struct

+ func (_c *AssetVersionService_HandleFirstPartyVulnResult_Call) Return(firstPartyVulns []models.FirstPartyVuln, ...) *AssetVersionService_HandleFirstPartyVulnResult_Call

+ func (_c *AssetVersionService_HandleFirstPartyVulnResult_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *AssetVersionService_HandleFirstPartyVulnResult_Call

+ func (_c *AssetVersionService_HandleFirstPartyVulnResult_Call) RunAndReturn(...) *AssetVersionService_HandleFirstPartyVulnResult_Call

+ type AssetVersionService_HandleScanResult_Call struct

+ func (_c *AssetVersionService_HandleScanResult_Call) Return(opened []models.DependencyVuln, closed []models.DependencyVuln, ...) *AssetVersionService_HandleScanResult_Call

+ func (_c *AssetVersionService_HandleScanResult_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *AssetVersionService_HandleScanResult_Call

+ func (_c *AssetVersionService_HandleScanResult_Call) RunAndReturn(...) *AssetVersionService_HandleScanResult_Call

+ type AssetVersionService_UpdateSBOM_Call struct

+ func (_c *AssetVersionService_UpdateSBOM_Call) Return(err error) *AssetVersionService_UpdateSBOM_Call

+ func (_c *AssetVersionService_UpdateSBOM_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *AssetVersionService_UpdateSBOM_Call

+ func (_c *AssetVersionService_UpdateSBOM_Call) RunAndReturn(...) *AssetVersionService_UpdateSBOM_Call

+ type AttestationRepository struct

+ func NewAttestationRepository(t interface{ ... }) *AttestationRepository

+ func (_m *AttestationRepository) EXPECT() *AttestationRepository_Expecter

+ func (_mock *AttestationRepository) Activate(tx core.DB, id string) error

+ func (_mock *AttestationRepository) All() ([]models.Attestation, error)

+ func (_mock *AttestationRepository) Begin() core.DB

+ func (_mock *AttestationRepository) Create(tx core.DB, t *models.Attestation) error

+ func (_mock *AttestationRepository) CreateBatch(tx core.DB, ts []models.Attestation) error

+ func (_mock *AttestationRepository) Delete(tx core.DB, id string) error

+ func (_mock *AttestationRepository) DeleteBatch(tx core.DB, ids []models.Attestation) error

+ func (_mock *AttestationRepository) GetByAssetID(assetID uuid.UUID) ([]models.Attestation, error)

+ func (_mock *AttestationRepository) GetByAssetVersionAndAssetID(assetID uuid.UUID, assetVersion string) ([]models.Attestation, error)

+ func (_mock *AttestationRepository) GetDB(tx core.DB) core.DB

+ func (_mock *AttestationRepository) List(ids []string) ([]models.Attestation, error)

+ func (_mock *AttestationRepository) Read(id string) (models.Attestation, error)

+ func (_mock *AttestationRepository) Save(tx core.DB, t *models.Attestation) error

+ func (_mock *AttestationRepository) SaveBatch(tx core.DB, ts []models.Attestation) error

+ func (_mock *AttestationRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *AttestationRepository) Upsert(t *[]*models.Attestation, conflictingColumns []clause.Column, ...) error

+ type AttestationRepository_Activate_Call struct

+ func (_c *AttestationRepository_Activate_Call) Return(err error) *AttestationRepository_Activate_Call

+ func (_c *AttestationRepository_Activate_Call) Run(run func(tx core.DB, id string)) *AttestationRepository_Activate_Call

+ func (_c *AttestationRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *AttestationRepository_Activate_Call

+ type AttestationRepository_All_Call struct

+ func (_c *AttestationRepository_All_Call) Return(attestations []models.Attestation, err error) *AttestationRepository_All_Call

+ func (_c *AttestationRepository_All_Call) Run(run func()) *AttestationRepository_All_Call

+ func (_c *AttestationRepository_All_Call) RunAndReturn(run func() ([]models.Attestation, error)) *AttestationRepository_All_Call

+ type AttestationRepository_Begin_Call struct

+ func (_c *AttestationRepository_Begin_Call) Return(v core.DB) *AttestationRepository_Begin_Call

+ func (_c *AttestationRepository_Begin_Call) Run(run func()) *AttestationRepository_Begin_Call

+ func (_c *AttestationRepository_Begin_Call) RunAndReturn(run func() core.DB) *AttestationRepository_Begin_Call

+ type AttestationRepository_CreateBatch_Call struct

+ func (_c *AttestationRepository_CreateBatch_Call) Return(err error) *AttestationRepository_CreateBatch_Call

+ func (_c *AttestationRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.Attestation)) *AttestationRepository_CreateBatch_Call

+ func (_c *AttestationRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Attestation) error) *AttestationRepository_CreateBatch_Call

+ type AttestationRepository_Create_Call struct

+ func (_c *AttestationRepository_Create_Call) Return(err error) *AttestationRepository_Create_Call

+ func (_c *AttestationRepository_Create_Call) Run(run func(tx core.DB, t *models.Attestation)) *AttestationRepository_Create_Call

+ func (_c *AttestationRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.Attestation) error) *AttestationRepository_Create_Call

+ type AttestationRepository_DeleteBatch_Call struct

+ func (_c *AttestationRepository_DeleteBatch_Call) Return(err error) *AttestationRepository_DeleteBatch_Call

+ func (_c *AttestationRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.Attestation)) *AttestationRepository_DeleteBatch_Call

+ func (_c *AttestationRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.Attestation) error) *AttestationRepository_DeleteBatch_Call

+ type AttestationRepository_Delete_Call struct

+ func (_c *AttestationRepository_Delete_Call) Return(err error) *AttestationRepository_Delete_Call

+ func (_c *AttestationRepository_Delete_Call) Run(run func(tx core.DB, id string)) *AttestationRepository_Delete_Call

+ func (_c *AttestationRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *AttestationRepository_Delete_Call

+ type AttestationRepository_Expecter struct

+ func (_e *AttestationRepository_Expecter) Activate(tx interface{}, id interface{}) *AttestationRepository_Activate_Call

+ func (_e *AttestationRepository_Expecter) All() *AttestationRepository_All_Call

+ func (_e *AttestationRepository_Expecter) Begin() *AttestationRepository_Begin_Call

+ func (_e *AttestationRepository_Expecter) Create(tx interface{}, t interface{}) *AttestationRepository_Create_Call

+ func (_e *AttestationRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *AttestationRepository_CreateBatch_Call

+ func (_e *AttestationRepository_Expecter) Delete(tx interface{}, id interface{}) *AttestationRepository_Delete_Call

+ func (_e *AttestationRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *AttestationRepository_DeleteBatch_Call

+ func (_e *AttestationRepository_Expecter) GetByAssetID(assetID interface{}) *AttestationRepository_GetByAssetID_Call

+ func (_e *AttestationRepository_Expecter) GetByAssetVersionAndAssetID(assetID interface{}, assetVersion interface{}) *AttestationRepository_GetByAssetVersionAndAssetID_Call

+ func (_e *AttestationRepository_Expecter) GetDB(tx interface{}) *AttestationRepository_GetDB_Call

+ func (_e *AttestationRepository_Expecter) List(ids interface{}) *AttestationRepository_List_Call

+ func (_e *AttestationRepository_Expecter) Read(id interface{}) *AttestationRepository_Read_Call

+ func (_e *AttestationRepository_Expecter) Save(tx interface{}, t interface{}) *AttestationRepository_Save_Call

+ func (_e *AttestationRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *AttestationRepository_SaveBatch_Call

+ func (_e *AttestationRepository_Expecter) Transaction(fn interface{}) *AttestationRepository_Transaction_Call

+ func (_e *AttestationRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *AttestationRepository_Upsert_Call

+ type AttestationRepository_GetByAssetID_Call struct

+ func (_c *AttestationRepository_GetByAssetID_Call) Return(attestations []models.Attestation, err error) *AttestationRepository_GetByAssetID_Call

+ func (_c *AttestationRepository_GetByAssetID_Call) Run(run func(assetID uuid.UUID)) *AttestationRepository_GetByAssetID_Call

+ func (_c *AttestationRepository_GetByAssetID_Call) RunAndReturn(run func(assetID uuid.UUID) ([]models.Attestation, error)) *AttestationRepository_GetByAssetID_Call

+ type AttestationRepository_GetByAssetVersionAndAssetID_Call struct

+ func (_c *AttestationRepository_GetByAssetVersionAndAssetID_Call) Return(attestations []models.Attestation, err error) *AttestationRepository_GetByAssetVersionAndAssetID_Call

+ func (_c *AttestationRepository_GetByAssetVersionAndAssetID_Call) Run(run func(assetID uuid.UUID, assetVersion string)) *AttestationRepository_GetByAssetVersionAndAssetID_Call

+ func (_c *AttestationRepository_GetByAssetVersionAndAssetID_Call) RunAndReturn(run func(assetID uuid.UUID, assetVersion string) ([]models.Attestation, error)) *AttestationRepository_GetByAssetVersionAndAssetID_Call

+ type AttestationRepository_GetDB_Call struct

+ func (_c *AttestationRepository_GetDB_Call) Return(v core.DB) *AttestationRepository_GetDB_Call

+ func (_c *AttestationRepository_GetDB_Call) Run(run func(tx core.DB)) *AttestationRepository_GetDB_Call

+ func (_c *AttestationRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *AttestationRepository_GetDB_Call

+ type AttestationRepository_List_Call struct

+ func (_c *AttestationRepository_List_Call) Return(attestations []models.Attestation, err error) *AttestationRepository_List_Call

+ func (_c *AttestationRepository_List_Call) Run(run func(ids []string)) *AttestationRepository_List_Call

+ func (_c *AttestationRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.Attestation, error)) *AttestationRepository_List_Call

+ type AttestationRepository_Read_Call struct

+ func (_c *AttestationRepository_Read_Call) Return(attestation models.Attestation, err error) *AttestationRepository_Read_Call

+ func (_c *AttestationRepository_Read_Call) Run(run func(id string)) *AttestationRepository_Read_Call

+ func (_c *AttestationRepository_Read_Call) RunAndReturn(run func(id string) (models.Attestation, error)) *AttestationRepository_Read_Call

+ type AttestationRepository_SaveBatch_Call struct

+ func (_c *AttestationRepository_SaveBatch_Call) Return(err error) *AttestationRepository_SaveBatch_Call

+ func (_c *AttestationRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.Attestation)) *AttestationRepository_SaveBatch_Call

+ func (_c *AttestationRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Attestation) error) *AttestationRepository_SaveBatch_Call

+ type AttestationRepository_Save_Call struct

+ func (_c *AttestationRepository_Save_Call) Return(err error) *AttestationRepository_Save_Call

+ func (_c *AttestationRepository_Save_Call) Run(run func(tx core.DB, t *models.Attestation)) *AttestationRepository_Save_Call

+ func (_c *AttestationRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.Attestation) error) *AttestationRepository_Save_Call

+ type AttestationRepository_Transaction_Call struct

+ func (_c *AttestationRepository_Transaction_Call) Return(err error) *AttestationRepository_Transaction_Call

+ func (_c *AttestationRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *AttestationRepository_Transaction_Call

+ func (_c *AttestationRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *AttestationRepository_Transaction_Call

+ type AttestationRepository_Upsert_Call struct

+ func (_c *AttestationRepository_Upsert_Call) Return(err error) *AttestationRepository_Upsert_Call

+ func (_c *AttestationRepository_Upsert_Call) Run(run func(t *[]*models.Attestation, conflictingColumns []clause.Column, ...)) *AttestationRepository_Upsert_Call

+ func (_c *AttestationRepository_Upsert_Call) RunAndReturn(...) *AttestationRepository_Upsert_Call

+ type AuthSession struct

+ func NewAuthSession(t interface{ ... }) *AuthSession

+ func (_m *AuthSession) EXPECT() *AuthSession_Expecter

+ func (_mock *AuthSession) GetScopes() []string

+ func (_mock *AuthSession) GetUserID() string

+ type AuthSession_Expecter struct

+ func (_e *AuthSession_Expecter) GetScopes() *AuthSession_GetScopes_Call

+ func (_e *AuthSession_Expecter) GetUserID() *AuthSession_GetUserID_Call

+ type AuthSession_GetScopes_Call struct

+ func (_c *AuthSession_GetScopes_Call) Return(strings []string) *AuthSession_GetScopes_Call

+ func (_c *AuthSession_GetScopes_Call) Run(run func()) *AuthSession_GetScopes_Call

+ func (_c *AuthSession_GetScopes_Call) RunAndReturn(run func() []string) *AuthSession_GetScopes_Call

+ type AuthSession_GetUserID_Call struct

+ func (_c *AuthSession_GetUserID_Call) Return(s string) *AuthSession_GetUserID_Call

+ func (_c *AuthSession_GetUserID_Call) Run(run func()) *AuthSession_GetUserID_Call

+ func (_c *AuthSession_GetUserID_Call) RunAndReturn(run func() string) *AuthSession_GetUserID_Call

+ type Comparer struct

+ func NewComparer(t interface{ ... }) *Comparer

+ func (_m *Comparer) EXPECT() *Comparer_Expecter

+ func (_mock *Comparer) GetVulns(purl string, notASemverVersion string, componentType string) ([]models.VulnInPackage, error)

+ type Comparer_Expecter struct

+ func (_e *Comparer_Expecter) GetVulns(purl interface{}, notASemverVersion interface{}, componentType interface{}) *Comparer_GetVulns_Call

+ type Comparer_GetVulns_Call struct

+ func (_c *Comparer_GetVulns_Call) Return(vulnInPackages []models.VulnInPackage, err error) *Comparer_GetVulns_Call

+ func (_c *Comparer_GetVulns_Call) Run(run func(purl string, notASemverVersion string, componentType string)) *Comparer_GetVulns_Call

+ func (_c *Comparer_GetVulns_Call) RunAndReturn(...) *Comparer_GetVulns_Call

+ type ComponentProjectRepository struct

+ func NewComponentProjectRepository(t interface{ ... }) *ComponentProjectRepository

+ func (_m *ComponentProjectRepository) EXPECT() *ComponentProjectRepository_Expecter

+ func (_mock *ComponentProjectRepository) Activate(tx core.DB, id string) error

+ func (_mock *ComponentProjectRepository) All() ([]models.ComponentProject, error)

+ func (_mock *ComponentProjectRepository) Begin() core.DB

+ func (_mock *ComponentProjectRepository) Create(tx core.DB, t *models.ComponentProject) error

+ func (_mock *ComponentProjectRepository) CreateBatch(tx core.DB, ts []models.ComponentProject) error

+ func (_mock *ComponentProjectRepository) Delete(tx core.DB, id string) error

+ func (_mock *ComponentProjectRepository) DeleteBatch(tx core.DB, ids []models.ComponentProject) error

+ func (_mock *ComponentProjectRepository) GetDB(tx core.DB) core.DB

+ func (_mock *ComponentProjectRepository) List(ids []string) ([]models.ComponentProject, error)

+ func (_mock *ComponentProjectRepository) Read(id string) (models.ComponentProject, error)

+ func (_mock *ComponentProjectRepository) Save(tx core.DB, t *models.ComponentProject) error

+ func (_mock *ComponentProjectRepository) SaveBatch(tx core.DB, ts []models.ComponentProject) error

+ func (_mock *ComponentProjectRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *ComponentProjectRepository) Upsert(t *[]*models.ComponentProject, conflictingColumns []clause.Column, ...) error

+ type ComponentProjectRepository_Activate_Call struct

+ func (_c *ComponentProjectRepository_Activate_Call) Return(err error) *ComponentProjectRepository_Activate_Call

+ func (_c *ComponentProjectRepository_Activate_Call) Run(run func(tx core.DB, id string)) *ComponentProjectRepository_Activate_Call

+ func (_c *ComponentProjectRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *ComponentProjectRepository_Activate_Call

+ type ComponentProjectRepository_All_Call struct

+ func (_c *ComponentProjectRepository_All_Call) Return(componentProjects []models.ComponentProject, err error) *ComponentProjectRepository_All_Call

+ func (_c *ComponentProjectRepository_All_Call) Run(run func()) *ComponentProjectRepository_All_Call

+ func (_c *ComponentProjectRepository_All_Call) RunAndReturn(run func() ([]models.ComponentProject, error)) *ComponentProjectRepository_All_Call

+ type ComponentProjectRepository_Begin_Call struct

+ func (_c *ComponentProjectRepository_Begin_Call) Return(v core.DB) *ComponentProjectRepository_Begin_Call

+ func (_c *ComponentProjectRepository_Begin_Call) Run(run func()) *ComponentProjectRepository_Begin_Call

+ func (_c *ComponentProjectRepository_Begin_Call) RunAndReturn(run func() core.DB) *ComponentProjectRepository_Begin_Call

+ type ComponentProjectRepository_CreateBatch_Call struct

+ func (_c *ComponentProjectRepository_CreateBatch_Call) Return(err error) *ComponentProjectRepository_CreateBatch_Call

+ func (_c *ComponentProjectRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.ComponentProject)) *ComponentProjectRepository_CreateBatch_Call

+ func (_c *ComponentProjectRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.ComponentProject) error) *ComponentProjectRepository_CreateBatch_Call

+ type ComponentProjectRepository_Create_Call struct

+ func (_c *ComponentProjectRepository_Create_Call) Return(err error) *ComponentProjectRepository_Create_Call

+ func (_c *ComponentProjectRepository_Create_Call) Run(run func(tx core.DB, t *models.ComponentProject)) *ComponentProjectRepository_Create_Call

+ func (_c *ComponentProjectRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.ComponentProject) error) *ComponentProjectRepository_Create_Call

+ type ComponentProjectRepository_DeleteBatch_Call struct

+ func (_c *ComponentProjectRepository_DeleteBatch_Call) Return(err error) *ComponentProjectRepository_DeleteBatch_Call

+ func (_c *ComponentProjectRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.ComponentProject)) *ComponentProjectRepository_DeleteBatch_Call

+ func (_c *ComponentProjectRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.ComponentProject) error) *ComponentProjectRepository_DeleteBatch_Call

+ type ComponentProjectRepository_Delete_Call struct

+ func (_c *ComponentProjectRepository_Delete_Call) Return(err error) *ComponentProjectRepository_Delete_Call

+ func (_c *ComponentProjectRepository_Delete_Call) Run(run func(tx core.DB, id string)) *ComponentProjectRepository_Delete_Call

+ func (_c *ComponentProjectRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *ComponentProjectRepository_Delete_Call

+ type ComponentProjectRepository_Expecter struct

+ func (_e *ComponentProjectRepository_Expecter) Activate(tx interface{}, id interface{}) *ComponentProjectRepository_Activate_Call

+ func (_e *ComponentProjectRepository_Expecter) All() *ComponentProjectRepository_All_Call

+ func (_e *ComponentProjectRepository_Expecter) Begin() *ComponentProjectRepository_Begin_Call

+ func (_e *ComponentProjectRepository_Expecter) Create(tx interface{}, t interface{}) *ComponentProjectRepository_Create_Call

+ func (_e *ComponentProjectRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *ComponentProjectRepository_CreateBatch_Call

+ func (_e *ComponentProjectRepository_Expecter) Delete(tx interface{}, id interface{}) *ComponentProjectRepository_Delete_Call

+ func (_e *ComponentProjectRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *ComponentProjectRepository_DeleteBatch_Call

+ func (_e *ComponentProjectRepository_Expecter) GetDB(tx interface{}) *ComponentProjectRepository_GetDB_Call

+ func (_e *ComponentProjectRepository_Expecter) List(ids interface{}) *ComponentProjectRepository_List_Call

+ func (_e *ComponentProjectRepository_Expecter) Read(id interface{}) *ComponentProjectRepository_Read_Call

+ func (_e *ComponentProjectRepository_Expecter) Save(tx interface{}, t interface{}) *ComponentProjectRepository_Save_Call

+ func (_e *ComponentProjectRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *ComponentProjectRepository_SaveBatch_Call

+ func (_e *ComponentProjectRepository_Expecter) Transaction(fn interface{}) *ComponentProjectRepository_Transaction_Call

+ func (_e *ComponentProjectRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *ComponentProjectRepository_Upsert_Call

+ type ComponentProjectRepository_GetDB_Call struct

+ func (_c *ComponentProjectRepository_GetDB_Call) Return(v core.DB) *ComponentProjectRepository_GetDB_Call

+ func (_c *ComponentProjectRepository_GetDB_Call) Run(run func(tx core.DB)) *ComponentProjectRepository_GetDB_Call

+ func (_c *ComponentProjectRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *ComponentProjectRepository_GetDB_Call

+ type ComponentProjectRepository_List_Call struct

+ func (_c *ComponentProjectRepository_List_Call) Return(componentProjects []models.ComponentProject, err error) *ComponentProjectRepository_List_Call

+ func (_c *ComponentProjectRepository_List_Call) Run(run func(ids []string)) *ComponentProjectRepository_List_Call

+ func (_c *ComponentProjectRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.ComponentProject, error)) *ComponentProjectRepository_List_Call

+ type ComponentProjectRepository_Read_Call struct

+ func (_c *ComponentProjectRepository_Read_Call) Return(componentProject models.ComponentProject, err error) *ComponentProjectRepository_Read_Call

+ func (_c *ComponentProjectRepository_Read_Call) Run(run func(id string)) *ComponentProjectRepository_Read_Call

+ func (_c *ComponentProjectRepository_Read_Call) RunAndReturn(run func(id string) (models.ComponentProject, error)) *ComponentProjectRepository_Read_Call

+ type ComponentProjectRepository_SaveBatch_Call struct

+ func (_c *ComponentProjectRepository_SaveBatch_Call) Return(err error) *ComponentProjectRepository_SaveBatch_Call

+ func (_c *ComponentProjectRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.ComponentProject)) *ComponentProjectRepository_SaveBatch_Call

+ func (_c *ComponentProjectRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.ComponentProject) error) *ComponentProjectRepository_SaveBatch_Call

+ type ComponentProjectRepository_Save_Call struct

+ func (_c *ComponentProjectRepository_Save_Call) Return(err error) *ComponentProjectRepository_Save_Call

+ func (_c *ComponentProjectRepository_Save_Call) Run(run func(tx core.DB, t *models.ComponentProject)) *ComponentProjectRepository_Save_Call

+ func (_c *ComponentProjectRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.ComponentProject) error) *ComponentProjectRepository_Save_Call

+ type ComponentProjectRepository_Transaction_Call struct

+ func (_c *ComponentProjectRepository_Transaction_Call) Return(err error) *ComponentProjectRepository_Transaction_Call

+ func (_c *ComponentProjectRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *ComponentProjectRepository_Transaction_Call

+ func (_c *ComponentProjectRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *ComponentProjectRepository_Transaction_Call

+ type ComponentProjectRepository_Upsert_Call struct

+ func (_c *ComponentProjectRepository_Upsert_Call) Return(err error) *ComponentProjectRepository_Upsert_Call

+ func (_c *ComponentProjectRepository_Upsert_Call) Run(...) *ComponentProjectRepository_Upsert_Call

+ func (_c *ComponentProjectRepository_Upsert_Call) RunAndReturn(...) *ComponentProjectRepository_Upsert_Call

+ type ComponentRepository struct

+ func NewComponentRepository(t interface{ ... }) *ComponentRepository

+ func (_m *ComponentRepository) EXPECT() *ComponentRepository_Expecter

+ func (_mock *ComponentRepository) Activate(tx core.DB, id string) error

+ func (_mock *ComponentRepository) All() ([]models.Component, error)

+ func (_mock *ComponentRepository) Begin() core.DB

+ func (_mock *ComponentRepository) Create(tx core.DB, t *models.Component) error

+ func (_mock *ComponentRepository) CreateBatch(tx core.DB, ts []models.Component) error

+ func (_mock *ComponentRepository) Delete(tx core.DB, id string) error

+ func (_mock *ComponentRepository) DeleteBatch(tx core.DB, ids []models.Component) error

+ func (_mock *ComponentRepository) FindByPurl(tx core.DB, purl string) (models.Component, error)

+ func (_mock *ComponentRepository) GetDB(tx core.DB) core.DB

+ func (_mock *ComponentRepository) GetLicenseDistribution(tx core.DB, assetVersionName string, assetID uuid.UUID, artifactName *string) (map[string]int, error)

+ func (_mock *ComponentRepository) HandleStateDiff(tx core.DB, assetVersionName string, assetID uuid.UUID, ...) (bool, error)

+ func (_mock *ComponentRepository) List(ids []string) ([]models.Component, error)

+ func (_mock *ComponentRepository) LoadComponents(tx core.DB, assetVersionName string, assetID uuid.UUID, artifactName *string) ([]models.ComponentDependency, error)

+ func (_mock *ComponentRepository) LoadComponentsWithProject(tx core.DB, overwrittenLicenses []models.LicenseRisk, assetVersionName string, ...) (core.Paged[models.ComponentDependency], error)

+ func (_mock *ComponentRepository) LoadPathToComponent(tx core.DB, assetVersionName string, assetID uuid.UUID, pURL string, ...) ([]models.ComponentDependency, error)

+ func (_mock *ComponentRepository) Read(id string) (models.Component, error)

+ func (_mock *ComponentRepository) Save(tx core.DB, t *models.Component) error

+ func (_mock *ComponentRepository) SaveBatch(tx core.DB, components []models.Component) error

+ func (_mock *ComponentRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *ComponentRepository) Upsert(t *[]*models.Component, conflictingColumns []clause.Column, ...) error

+ type ComponentRepository_Activate_Call struct

+ func (_c *ComponentRepository_Activate_Call) Return(err error) *ComponentRepository_Activate_Call

+ func (_c *ComponentRepository_Activate_Call) Run(run func(tx core.DB, id string)) *ComponentRepository_Activate_Call

+ func (_c *ComponentRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *ComponentRepository_Activate_Call

+ type ComponentRepository_All_Call struct

+ func (_c *ComponentRepository_All_Call) Return(components []models.Component, err error) *ComponentRepository_All_Call

+ func (_c *ComponentRepository_All_Call) Run(run func()) *ComponentRepository_All_Call

+ func (_c *ComponentRepository_All_Call) RunAndReturn(run func() ([]models.Component, error)) *ComponentRepository_All_Call

+ type ComponentRepository_Begin_Call struct

+ func (_c *ComponentRepository_Begin_Call) Return(v core.DB) *ComponentRepository_Begin_Call

+ func (_c *ComponentRepository_Begin_Call) Run(run func()) *ComponentRepository_Begin_Call

+ func (_c *ComponentRepository_Begin_Call) RunAndReturn(run func() core.DB) *ComponentRepository_Begin_Call

+ type ComponentRepository_CreateBatch_Call struct

+ func (_c *ComponentRepository_CreateBatch_Call) Return(err error) *ComponentRepository_CreateBatch_Call

+ func (_c *ComponentRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.Component)) *ComponentRepository_CreateBatch_Call

+ func (_c *ComponentRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Component) error) *ComponentRepository_CreateBatch_Call

+ type ComponentRepository_Create_Call struct

+ func (_c *ComponentRepository_Create_Call) Return(err error) *ComponentRepository_Create_Call

+ func (_c *ComponentRepository_Create_Call) Run(run func(tx core.DB, t *models.Component)) *ComponentRepository_Create_Call

+ func (_c *ComponentRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.Component) error) *ComponentRepository_Create_Call

+ type ComponentRepository_DeleteBatch_Call struct

+ func (_c *ComponentRepository_DeleteBatch_Call) Return(err error) *ComponentRepository_DeleteBatch_Call

+ func (_c *ComponentRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.Component)) *ComponentRepository_DeleteBatch_Call

+ func (_c *ComponentRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.Component) error) *ComponentRepository_DeleteBatch_Call

+ type ComponentRepository_Delete_Call struct

+ func (_c *ComponentRepository_Delete_Call) Return(err error) *ComponentRepository_Delete_Call

+ func (_c *ComponentRepository_Delete_Call) Run(run func(tx core.DB, id string)) *ComponentRepository_Delete_Call

+ func (_c *ComponentRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *ComponentRepository_Delete_Call

+ type ComponentRepository_Expecter struct

+ func (_e *ComponentRepository_Expecter) Activate(tx interface{}, id interface{}) *ComponentRepository_Activate_Call

+ func (_e *ComponentRepository_Expecter) All() *ComponentRepository_All_Call

+ func (_e *ComponentRepository_Expecter) Begin() *ComponentRepository_Begin_Call

+ func (_e *ComponentRepository_Expecter) Create(tx interface{}, t interface{}) *ComponentRepository_Create_Call

+ func (_e *ComponentRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *ComponentRepository_CreateBatch_Call

+ func (_e *ComponentRepository_Expecter) Delete(tx interface{}, id interface{}) *ComponentRepository_Delete_Call

+ func (_e *ComponentRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *ComponentRepository_DeleteBatch_Call

+ func (_e *ComponentRepository_Expecter) FindByPurl(tx interface{}, purl interface{}) *ComponentRepository_FindByPurl_Call

+ func (_e *ComponentRepository_Expecter) GetDB(tx interface{}) *ComponentRepository_GetDB_Call

+ func (_e *ComponentRepository_Expecter) GetLicenseDistribution(tx interface{}, assetVersionName interface{}, assetID interface{}, ...) *ComponentRepository_GetLicenseDistribution_Call

+ func (_e *ComponentRepository_Expecter) HandleStateDiff(tx interface{}, assetVersionName interface{}, assetID interface{}, ...) *ComponentRepository_HandleStateDiff_Call

+ func (_e *ComponentRepository_Expecter) List(ids interface{}) *ComponentRepository_List_Call

+ func (_e *ComponentRepository_Expecter) LoadComponents(tx interface{}, assetVersionName interface{}, assetID interface{}, ...) *ComponentRepository_LoadComponents_Call

+ func (_e *ComponentRepository_Expecter) LoadComponentsWithProject(tx interface{}, overwrittenLicenses interface{}, assetVersionName interface{}, ...) *ComponentRepository_LoadComponentsWithProject_Call

+ func (_e *ComponentRepository_Expecter) LoadPathToComponent(tx interface{}, assetVersionName interface{}, assetID interface{}, ...) *ComponentRepository_LoadPathToComponent_Call

+ func (_e *ComponentRepository_Expecter) Read(id interface{}) *ComponentRepository_Read_Call

+ func (_e *ComponentRepository_Expecter) Save(tx interface{}, t interface{}) *ComponentRepository_Save_Call

+ func (_e *ComponentRepository_Expecter) SaveBatch(tx interface{}, components interface{}) *ComponentRepository_SaveBatch_Call

+ func (_e *ComponentRepository_Expecter) Transaction(fn interface{}) *ComponentRepository_Transaction_Call

+ func (_e *ComponentRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *ComponentRepository_Upsert_Call

+ type ComponentRepository_FindByPurl_Call struct

+ func (_c *ComponentRepository_FindByPurl_Call) Return(component models.Component, err error) *ComponentRepository_FindByPurl_Call

+ func (_c *ComponentRepository_FindByPurl_Call) Run(run func(tx core.DB, purl string)) *ComponentRepository_FindByPurl_Call

+ func (_c *ComponentRepository_FindByPurl_Call) RunAndReturn(run func(tx core.DB, purl string) (models.Component, error)) *ComponentRepository_FindByPurl_Call

+ type ComponentRepository_GetDB_Call struct

+ func (_c *ComponentRepository_GetDB_Call) Return(v core.DB) *ComponentRepository_GetDB_Call

+ func (_c *ComponentRepository_GetDB_Call) Run(run func(tx core.DB)) *ComponentRepository_GetDB_Call

+ func (_c *ComponentRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *ComponentRepository_GetDB_Call

+ type ComponentRepository_GetLicenseDistribution_Call struct

+ func (_c *ComponentRepository_GetLicenseDistribution_Call) Return(stringToInt map[string]int, err error) *ComponentRepository_GetLicenseDistribution_Call

+ func (_c *ComponentRepository_GetLicenseDistribution_Call) Run(...) *ComponentRepository_GetLicenseDistribution_Call

+ func (_c *ComponentRepository_GetLicenseDistribution_Call) RunAndReturn(...) *ComponentRepository_GetLicenseDistribution_Call

+ type ComponentRepository_HandleStateDiff_Call struct

+ func (_c *ComponentRepository_HandleStateDiff_Call) Return(b bool, err error) *ComponentRepository_HandleStateDiff_Call

+ func (_c *ComponentRepository_HandleStateDiff_Call) Run(run func(tx core.DB, assetVersionName string, assetID uuid.UUID, ...)) *ComponentRepository_HandleStateDiff_Call

+ func (_c *ComponentRepository_HandleStateDiff_Call) RunAndReturn(...) *ComponentRepository_HandleStateDiff_Call

+ type ComponentRepository_List_Call struct

+ func (_c *ComponentRepository_List_Call) Return(components []models.Component, err error) *ComponentRepository_List_Call

+ func (_c *ComponentRepository_List_Call) Run(run func(ids []string)) *ComponentRepository_List_Call

+ func (_c *ComponentRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.Component, error)) *ComponentRepository_List_Call

+ type ComponentRepository_LoadComponentsWithProject_Call struct

+ func (_c *ComponentRepository_LoadComponentsWithProject_Call) Return(paged core.Paged[models.ComponentDependency], err error) *ComponentRepository_LoadComponentsWithProject_Call

+ func (_c *ComponentRepository_LoadComponentsWithProject_Call) Run(...) *ComponentRepository_LoadComponentsWithProject_Call

+ func (_c *ComponentRepository_LoadComponentsWithProject_Call) RunAndReturn(...) *ComponentRepository_LoadComponentsWithProject_Call

+ type ComponentRepository_LoadComponents_Call struct

+ func (_c *ComponentRepository_LoadComponents_Call) Return(componentDependencys []models.ComponentDependency, err error) *ComponentRepository_LoadComponents_Call

+ func (_c *ComponentRepository_LoadComponents_Call) Run(...) *ComponentRepository_LoadComponents_Call

+ func (_c *ComponentRepository_LoadComponents_Call) RunAndReturn(...) *ComponentRepository_LoadComponents_Call

+ type ComponentRepository_LoadPathToComponent_Call struct

+ func (_c *ComponentRepository_LoadPathToComponent_Call) Return(componentDependencys []models.ComponentDependency, err error) *ComponentRepository_LoadPathToComponent_Call

+ func (_c *ComponentRepository_LoadPathToComponent_Call) Run(...) *ComponentRepository_LoadPathToComponent_Call

+ func (_c *ComponentRepository_LoadPathToComponent_Call) RunAndReturn(...) *ComponentRepository_LoadPathToComponent_Call

+ type ComponentRepository_Read_Call struct

+ func (_c *ComponentRepository_Read_Call) Return(component models.Component, err error) *ComponentRepository_Read_Call

+ func (_c *ComponentRepository_Read_Call) Run(run func(id string)) *ComponentRepository_Read_Call

+ func (_c *ComponentRepository_Read_Call) RunAndReturn(run func(id string) (models.Component, error)) *ComponentRepository_Read_Call

+ type ComponentRepository_SaveBatch_Call struct

+ func (_c *ComponentRepository_SaveBatch_Call) Return(err error) *ComponentRepository_SaveBatch_Call

+ func (_c *ComponentRepository_SaveBatch_Call) Run(run func(tx core.DB, components []models.Component)) *ComponentRepository_SaveBatch_Call

+ func (_c *ComponentRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, components []models.Component) error) *ComponentRepository_SaveBatch_Call

+ type ComponentRepository_Save_Call struct

+ func (_c *ComponentRepository_Save_Call) Return(err error) *ComponentRepository_Save_Call

+ func (_c *ComponentRepository_Save_Call) Run(run func(tx core.DB, t *models.Component)) *ComponentRepository_Save_Call

+ func (_c *ComponentRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.Component) error) *ComponentRepository_Save_Call

+ type ComponentRepository_Transaction_Call struct

+ func (_c *ComponentRepository_Transaction_Call) Return(err error) *ComponentRepository_Transaction_Call

+ func (_c *ComponentRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *ComponentRepository_Transaction_Call

+ func (_c *ComponentRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *ComponentRepository_Transaction_Call

+ type ComponentRepository_Upsert_Call struct

+ func (_c *ComponentRepository_Upsert_Call) Return(err error) *ComponentRepository_Upsert_Call

+ func (_c *ComponentRepository_Upsert_Call) Run(run func(t *[]*models.Component, conflictingColumns []clause.Column, ...)) *ComponentRepository_Upsert_Call

+ func (_c *ComponentRepository_Upsert_Call) RunAndReturn(...) *ComponentRepository_Upsert_Call

+ type ComponentService struct

+ func NewComponentService(t interface{ ... }) *ComponentService

+ func (_m *ComponentService) EXPECT() *ComponentService_Expecter

+ func (_mock *ComponentService) GetAndSaveLicenseInformation(assetVersion models.AssetVersion, artifactName *string, forceRefresh bool) ([]models.Component, error)

+ func (_mock *ComponentService) GetLicense(component models.Component) (models.Component, error)

+ func (_mock *ComponentService) RefreshComponentProjectInformation(project models.ComponentProject)

+ type ComponentService_Expecter struct

+ func (_e *ComponentService_Expecter) GetAndSaveLicenseInformation(assetVersion interface{}, artifactName interface{}, forceRefresh interface{}) *ComponentService_GetAndSaveLicenseInformation_Call

+ func (_e *ComponentService_Expecter) GetLicense(component interface{}) *ComponentService_GetLicense_Call

+ func (_e *ComponentService_Expecter) RefreshComponentProjectInformation(project interface{}) *ComponentService_RefreshComponentProjectInformation_Call

+ type ComponentService_GetAndSaveLicenseInformation_Call struct

+ func (_c *ComponentService_GetAndSaveLicenseInformation_Call) Return(components []models.Component, err error) *ComponentService_GetAndSaveLicenseInformation_Call

+ func (_c *ComponentService_GetAndSaveLicenseInformation_Call) Run(...) *ComponentService_GetAndSaveLicenseInformation_Call

+ func (_c *ComponentService_GetAndSaveLicenseInformation_Call) RunAndReturn(...) *ComponentService_GetAndSaveLicenseInformation_Call

+ type ComponentService_GetLicense_Call struct

+ func (_c *ComponentService_GetLicense_Call) Return(component1 models.Component, err error) *ComponentService_GetLicense_Call

+ func (_c *ComponentService_GetLicense_Call) Run(run func(component models.Component)) *ComponentService_GetLicense_Call

+ func (_c *ComponentService_GetLicense_Call) RunAndReturn(run func(component models.Component) (models.Component, error)) *ComponentService_GetLicense_Call

+ type ComponentService_RefreshComponentProjectInformation_Call struct

+ func (_c *ComponentService_RefreshComponentProjectInformation_Call) Return() *ComponentService_RefreshComponentProjectInformation_Call

+ func (_c *ComponentService_RefreshComponentProjectInformation_Call) Run(run func(project models.ComponentProject)) *ComponentService_RefreshComponentProjectInformation_Call

+ func (_c *ComponentService_RefreshComponentProjectInformation_Call) RunAndReturn(run func(project models.ComponentProject)) *ComponentService_RefreshComponentProjectInformation_Call

+ type ConfigRepository struct

+ func NewConfigRepository(t interface{ ... }) *ConfigRepository

+ func (_m *ConfigRepository) EXPECT() *ConfigRepository_Expecter

+ func (_mock *ConfigRepository) GetDB(tx core.DB) core.DB

+ func (_mock *ConfigRepository) Save(tx core.DB, config *models.Config) error

+ type ConfigRepository_Expecter struct

+ func (_e *ConfigRepository_Expecter) GetDB(tx interface{}) *ConfigRepository_GetDB_Call

+ func (_e *ConfigRepository_Expecter) Save(tx interface{}, config interface{}) *ConfigRepository_Save_Call

+ type ConfigRepository_GetDB_Call struct

+ func (_c *ConfigRepository_GetDB_Call) Return(v core.DB) *ConfigRepository_GetDB_Call

+ func (_c *ConfigRepository_GetDB_Call) Run(run func(tx core.DB)) *ConfigRepository_GetDB_Call

+ func (_c *ConfigRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *ConfigRepository_GetDB_Call

+ type ConfigRepository_Save_Call struct

+ func (_c *ConfigRepository_Save_Call) Return(err error) *ConfigRepository_Save_Call

+ func (_c *ConfigRepository_Save_Call) Run(run func(tx core.DB, config *models.Config)) *ConfigRepository_Save_Call

+ func (_c *ConfigRepository_Save_Call) RunAndReturn(run func(tx core.DB, config *models.Config) error) *ConfigRepository_Save_Call

+ type ConfigService struct

+ func NewConfigService(t interface{ ... }) *ConfigService

+ func (_m *ConfigService) EXPECT() *ConfigService_Expecter

+ func (_mock *ConfigService) GetJSONConfig(key string, v any) error

+ func (_mock *ConfigService) SetJSONConfig(key string, v any) error

+ type ConfigService_Expecter struct

+ func (_e *ConfigService_Expecter) GetJSONConfig(key interface{}, v interface{}) *ConfigService_GetJSONConfig_Call

+ func (_e *ConfigService_Expecter) SetJSONConfig(key interface{}, v interface{}) *ConfigService_SetJSONConfig_Call

+ type ConfigService_GetJSONConfig_Call struct

+ func (_c *ConfigService_GetJSONConfig_Call) Return(err error) *ConfigService_GetJSONConfig_Call

+ func (_c *ConfigService_GetJSONConfig_Call) Run(run func(key string, v any)) *ConfigService_GetJSONConfig_Call

+ func (_c *ConfigService_GetJSONConfig_Call) RunAndReturn(run func(key string, v any) error) *ConfigService_GetJSONConfig_Call

+ type ConfigService_SetJSONConfig_Call struct

+ func (_c *ConfigService_SetJSONConfig_Call) Return(err error) *ConfigService_SetJSONConfig_Call

+ func (_c *ConfigService_SetJSONConfig_Call) Run(run func(key string, v any)) *ConfigService_SetJSONConfig_Call

+ func (_c *ConfigService_SetJSONConfig_Call) RunAndReturn(run func(key string, v any) error) *ConfigService_SetJSONConfig_Call

+ type Context struct

+ func NewContext(t interface{ ... }) *Context

+ func (_m *Context) EXPECT() *Context_Expecter

+ func (_mock *Context) Attachment(file string, name string) error

+ func (_mock *Context) Bind(i interface{}) error

+ func (_mock *Context) Blob(code int, contentType string, b []byte) error

+ func (_mock *Context) Cookie(name string) (*http.Cookie, error)

+ func (_mock *Context) Cookies() []*http.Cookie

+ func (_mock *Context) Echo() *echo.Echo

+ func (_mock *Context) Error(err error)

+ func (_mock *Context) File(file string) error

+ func (_mock *Context) FormFile(name string) (*multipart.FileHeader, error)

+ func (_mock *Context) FormParams() (url.Values, error)

+ func (_mock *Context) FormValue(name string) string

+ func (_mock *Context) Get(key string) interface{}

+ func (_mock *Context) HTML(code int, html string) error

+ func (_mock *Context) HTMLBlob(code int, b []byte) error

+ func (_mock *Context) Handler() echo.HandlerFunc

+ func (_mock *Context) Inline(file string, name string) error

+ func (_mock *Context) IsTLS() bool

+ func (_mock *Context) IsWebSocket() bool

+ func (_mock *Context) JSON(code int, i interface{}) error

+ func (_mock *Context) JSONBlob(code int, b []byte) error

+ func (_mock *Context) JSONP(code int, callback string, i interface{}) error

+ func (_mock *Context) JSONPBlob(code int, callback string, b []byte) error

+ func (_mock *Context) JSONPretty(code int, i interface{}, indent string) error

+ func (_mock *Context) Logger() echo.Logger

+ func (_mock *Context) MultipartForm() (*multipart.Form, error)

+ func (_mock *Context) NoContent(code int) error

+ func (_mock *Context) Param(name string) string

+ func (_mock *Context) ParamNames() []string

+ func (_mock *Context) ParamValues() []string

+ func (_mock *Context) Path() string

+ func (_mock *Context) QueryParam(name string) string

+ func (_mock *Context) QueryParams() url.Values

+ func (_mock *Context) QueryString() string

+ func (_mock *Context) RealIP() string

+ func (_mock *Context) Redirect(code int, url1 string) error

+ func (_mock *Context) Render(code int, name string, data interface{}) error

+ func (_mock *Context) Request() *http.Request

+ func (_mock *Context) Reset(r *http.Request, w http.ResponseWriter)

+ func (_mock *Context) Response() *echo.Response

+ func (_mock *Context) Scheme() string

+ func (_mock *Context) Set(key string, val interface{})

+ func (_mock *Context) SetCookie(cookie *http.Cookie)

+ func (_mock *Context) SetHandler(h echo.HandlerFunc)

+ func (_mock *Context) SetLogger(l echo.Logger)

+ func (_mock *Context) SetParamNames(names ...string)

+ func (_mock *Context) SetParamValues(values ...string)

+ func (_mock *Context) SetPath(p string)

+ func (_mock *Context) SetRequest(r *http.Request)

+ func (_mock *Context) SetResponse(r *echo.Response)

+ func (_mock *Context) Stream(code int, contentType string, r io.Reader) error

+ func (_mock *Context) String(code int, s string) error

+ func (_mock *Context) Validate(i interface{}) error

+ func (_mock *Context) XML(code int, i interface{}) error

+ func (_mock *Context) XMLBlob(code int, b []byte) error

+ func (_mock *Context) XMLPretty(code int, i interface{}, indent string) error

+ type Context_Attachment_Call struct

+ func (_c *Context_Attachment_Call) Return(err error) *Context_Attachment_Call

+ func (_c *Context_Attachment_Call) Run(run func(file string, name string)) *Context_Attachment_Call

+ func (_c *Context_Attachment_Call) RunAndReturn(run func(file string, name string) error) *Context_Attachment_Call

+ type Context_Bind_Call struct

+ func (_c *Context_Bind_Call) Return(err error) *Context_Bind_Call

+ func (_c *Context_Bind_Call) Run(run func(i interface{})) *Context_Bind_Call

+ func (_c *Context_Bind_Call) RunAndReturn(run func(i interface{}) error) *Context_Bind_Call

+ type Context_Blob_Call struct

+ func (_c *Context_Blob_Call) Return(err error) *Context_Blob_Call

+ func (_c *Context_Blob_Call) Run(run func(code int, contentType string, b []byte)) *Context_Blob_Call

+ func (_c *Context_Blob_Call) RunAndReturn(run func(code int, contentType string, b []byte) error) *Context_Blob_Call

+ type Context_Cookie_Call struct

+ func (_c *Context_Cookie_Call) Return(cookie *http.Cookie, err error) *Context_Cookie_Call

+ func (_c *Context_Cookie_Call) Run(run func(name string)) *Context_Cookie_Call

+ func (_c *Context_Cookie_Call) RunAndReturn(run func(name string) (*http.Cookie, error)) *Context_Cookie_Call

+ type Context_Cookies_Call struct

+ func (_c *Context_Cookies_Call) Return(cookies []*http.Cookie) *Context_Cookies_Call

+ func (_c *Context_Cookies_Call) Run(run func()) *Context_Cookies_Call

+ func (_c *Context_Cookies_Call) RunAndReturn(run func() []*http.Cookie) *Context_Cookies_Call

+ type Context_Echo_Call struct

+ func (_c *Context_Echo_Call) Return(echo1 *echo.Echo) *Context_Echo_Call

+ func (_c *Context_Echo_Call) Run(run func()) *Context_Echo_Call

+ func (_c *Context_Echo_Call) RunAndReturn(run func() *echo.Echo) *Context_Echo_Call

+ type Context_Error_Call struct

+ func (_c *Context_Error_Call) Return() *Context_Error_Call

+ func (_c *Context_Error_Call) Run(run func(err error)) *Context_Error_Call

+ func (_c *Context_Error_Call) RunAndReturn(run func(err error)) *Context_Error_Call

+ type Context_Expecter struct

+ func (_e *Context_Expecter) Attachment(file interface{}, name interface{}) *Context_Attachment_Call

+ func (_e *Context_Expecter) Bind(i interface{}) *Context_Bind_Call

+ func (_e *Context_Expecter) Blob(code interface{}, contentType interface{}, b interface{}) *Context_Blob_Call

+ func (_e *Context_Expecter) Cookie(name interface{}) *Context_Cookie_Call

+ func (_e *Context_Expecter) Cookies() *Context_Cookies_Call

+ func (_e *Context_Expecter) Echo() *Context_Echo_Call

+ func (_e *Context_Expecter) Error(err interface{}) *Context_Error_Call

+ func (_e *Context_Expecter) File(file interface{}) *Context_File_Call

+ func (_e *Context_Expecter) FormFile(name interface{}) *Context_FormFile_Call

+ func (_e *Context_Expecter) FormParams() *Context_FormParams_Call

+ func (_e *Context_Expecter) FormValue(name interface{}) *Context_FormValue_Call

+ func (_e *Context_Expecter) Get(key interface{}) *Context_Get_Call

+ func (_e *Context_Expecter) HTML(code interface{}, html interface{}) *Context_HTML_Call

+ func (_e *Context_Expecter) HTMLBlob(code interface{}, b interface{}) *Context_HTMLBlob_Call

+ func (_e *Context_Expecter) Handler() *Context_Handler_Call

+ func (_e *Context_Expecter) Inline(file interface{}, name interface{}) *Context_Inline_Call

+ func (_e *Context_Expecter) IsTLS() *Context_IsTLS_Call

+ func (_e *Context_Expecter) IsWebSocket() *Context_IsWebSocket_Call

+ func (_e *Context_Expecter) JSON(code interface{}, i interface{}) *Context_JSON_Call

+ func (_e *Context_Expecter) JSONBlob(code interface{}, b interface{}) *Context_JSONBlob_Call

+ func (_e *Context_Expecter) JSONP(code interface{}, callback interface{}, i interface{}) *Context_JSONP_Call

+ func (_e *Context_Expecter) JSONPBlob(code interface{}, callback interface{}, b interface{}) *Context_JSONPBlob_Call

+ func (_e *Context_Expecter) JSONPretty(code interface{}, i interface{}, indent interface{}) *Context_JSONPretty_Call

+ func (_e *Context_Expecter) Logger() *Context_Logger_Call

+ func (_e *Context_Expecter) MultipartForm() *Context_MultipartForm_Call

+ func (_e *Context_Expecter) NoContent(code interface{}) *Context_NoContent_Call

+ func (_e *Context_Expecter) Param(name interface{}) *Context_Param_Call

+ func (_e *Context_Expecter) ParamNames() *Context_ParamNames_Call

+ func (_e *Context_Expecter) ParamValues() *Context_ParamValues_Call

+ func (_e *Context_Expecter) Path() *Context_Path_Call

+ func (_e *Context_Expecter) QueryParam(name interface{}) *Context_QueryParam_Call

+ func (_e *Context_Expecter) QueryParams() *Context_QueryParams_Call

+ func (_e *Context_Expecter) QueryString() *Context_QueryString_Call

+ func (_e *Context_Expecter) RealIP() *Context_RealIP_Call

+ func (_e *Context_Expecter) Redirect(code interface{}, url1 interface{}) *Context_Redirect_Call

+ func (_e *Context_Expecter) Render(code interface{}, name interface{}, data interface{}) *Context_Render_Call

+ func (_e *Context_Expecter) Request() *Context_Request_Call

+ func (_e *Context_Expecter) Reset(r interface{}, w interface{}) *Context_Reset_Call

+ func (_e *Context_Expecter) Response() *Context_Response_Call

+ func (_e *Context_Expecter) Scheme() *Context_Scheme_Call

+ func (_e *Context_Expecter) Set(key interface{}, val interface{}) *Context_Set_Call

+ func (_e *Context_Expecter) SetCookie(cookie interface{}) *Context_SetCookie_Call

+ func (_e *Context_Expecter) SetHandler(h interface{}) *Context_SetHandler_Call

+ func (_e *Context_Expecter) SetLogger(l interface{}) *Context_SetLogger_Call

+ func (_e *Context_Expecter) SetParamNames(names ...interface{}) *Context_SetParamNames_Call

+ func (_e *Context_Expecter) SetParamValues(values ...interface{}) *Context_SetParamValues_Call

+ func (_e *Context_Expecter) SetPath(p interface{}) *Context_SetPath_Call

+ func (_e *Context_Expecter) SetRequest(r interface{}) *Context_SetRequest_Call

+ func (_e *Context_Expecter) SetResponse(r interface{}) *Context_SetResponse_Call

+ func (_e *Context_Expecter) Stream(code interface{}, contentType interface{}, r interface{}) *Context_Stream_Call

+ func (_e *Context_Expecter) String(code interface{}, s interface{}) *Context_String_Call

+ func (_e *Context_Expecter) Validate(i interface{}) *Context_Validate_Call

+ func (_e *Context_Expecter) XML(code interface{}, i interface{}) *Context_XML_Call

+ func (_e *Context_Expecter) XMLBlob(code interface{}, b interface{}) *Context_XMLBlob_Call

+ func (_e *Context_Expecter) XMLPretty(code interface{}, i interface{}, indent interface{}) *Context_XMLPretty_Call

+ type Context_File_Call struct

+ func (_c *Context_File_Call) Return(err error) *Context_File_Call

+ func (_c *Context_File_Call) Run(run func(file string)) *Context_File_Call

+ func (_c *Context_File_Call) RunAndReturn(run func(file string) error) *Context_File_Call

+ type Context_FormFile_Call struct

+ func (_c *Context_FormFile_Call) Return(fileHeader *multipart.FileHeader, err error) *Context_FormFile_Call

+ func (_c *Context_FormFile_Call) Run(run func(name string)) *Context_FormFile_Call

+ func (_c *Context_FormFile_Call) RunAndReturn(run func(name string) (*multipart.FileHeader, error)) *Context_FormFile_Call

+ type Context_FormParams_Call struct

+ func (_c *Context_FormParams_Call) Return(values url.Values, err error) *Context_FormParams_Call

+ func (_c *Context_FormParams_Call) Run(run func()) *Context_FormParams_Call

+ func (_c *Context_FormParams_Call) RunAndReturn(run func() (url.Values, error)) *Context_FormParams_Call

+ type Context_FormValue_Call struct

+ func (_c *Context_FormValue_Call) Return(s string) *Context_FormValue_Call

+ func (_c *Context_FormValue_Call) Run(run func(name string)) *Context_FormValue_Call

+ func (_c *Context_FormValue_Call) RunAndReturn(run func(name string) string) *Context_FormValue_Call

+ type Context_Get_Call struct

+ func (_c *Context_Get_Call) Return(ifaceVal interface{}) *Context_Get_Call

+ func (_c *Context_Get_Call) Run(run func(key string)) *Context_Get_Call

+ func (_c *Context_Get_Call) RunAndReturn(run func(key string) interface{}) *Context_Get_Call

+ type Context_HTMLBlob_Call struct

+ func (_c *Context_HTMLBlob_Call) Return(err error) *Context_HTMLBlob_Call

+ func (_c *Context_HTMLBlob_Call) Run(run func(code int, b []byte)) *Context_HTMLBlob_Call

+ func (_c *Context_HTMLBlob_Call) RunAndReturn(run func(code int, b []byte) error) *Context_HTMLBlob_Call

+ type Context_HTML_Call struct

+ func (_c *Context_HTML_Call) Return(err error) *Context_HTML_Call

+ func (_c *Context_HTML_Call) Run(run func(code int, html string)) *Context_HTML_Call

+ func (_c *Context_HTML_Call) RunAndReturn(run func(code int, html string) error) *Context_HTML_Call

+ type Context_Handler_Call struct

+ func (_c *Context_Handler_Call) Return(handlerFunc echo.HandlerFunc) *Context_Handler_Call

+ func (_c *Context_Handler_Call) Run(run func()) *Context_Handler_Call

+ func (_c *Context_Handler_Call) RunAndReturn(run func() echo.HandlerFunc) *Context_Handler_Call

+ type Context_Inline_Call struct

+ func (_c *Context_Inline_Call) Return(err error) *Context_Inline_Call

+ func (_c *Context_Inline_Call) Run(run func(file string, name string)) *Context_Inline_Call

+ func (_c *Context_Inline_Call) RunAndReturn(run func(file string, name string) error) *Context_Inline_Call

+ type Context_IsTLS_Call struct

+ func (_c *Context_IsTLS_Call) Return(b bool) *Context_IsTLS_Call

+ func (_c *Context_IsTLS_Call) Run(run func()) *Context_IsTLS_Call

+ func (_c *Context_IsTLS_Call) RunAndReturn(run func() bool) *Context_IsTLS_Call

+ type Context_IsWebSocket_Call struct

+ func (_c *Context_IsWebSocket_Call) Return(b bool) *Context_IsWebSocket_Call

+ func (_c *Context_IsWebSocket_Call) Run(run func()) *Context_IsWebSocket_Call

+ func (_c *Context_IsWebSocket_Call) RunAndReturn(run func() bool) *Context_IsWebSocket_Call

+ type Context_JSONBlob_Call struct

+ func (_c *Context_JSONBlob_Call) Return(err error) *Context_JSONBlob_Call

+ func (_c *Context_JSONBlob_Call) Run(run func(code int, b []byte)) *Context_JSONBlob_Call

+ func (_c *Context_JSONBlob_Call) RunAndReturn(run func(code int, b []byte) error) *Context_JSONBlob_Call

+ type Context_JSONPBlob_Call struct

+ func (_c *Context_JSONPBlob_Call) Return(err error) *Context_JSONPBlob_Call

+ func (_c *Context_JSONPBlob_Call) Run(run func(code int, callback string, b []byte)) *Context_JSONPBlob_Call

+ func (_c *Context_JSONPBlob_Call) RunAndReturn(run func(code int, callback string, b []byte) error) *Context_JSONPBlob_Call

+ type Context_JSONP_Call struct

+ func (_c *Context_JSONP_Call) Return(err error) *Context_JSONP_Call

+ func (_c *Context_JSONP_Call) Run(run func(code int, callback string, i interface{})) *Context_JSONP_Call

+ func (_c *Context_JSONP_Call) RunAndReturn(run func(code int, callback string, i interface{}) error) *Context_JSONP_Call

+ type Context_JSONPretty_Call struct

+ func (_c *Context_JSONPretty_Call) Return(err error) *Context_JSONPretty_Call

+ func (_c *Context_JSONPretty_Call) Run(run func(code int, i interface{}, indent string)) *Context_JSONPretty_Call

+ func (_c *Context_JSONPretty_Call) RunAndReturn(run func(code int, i interface{}, indent string) error) *Context_JSONPretty_Call

+ type Context_JSON_Call struct

+ func (_c *Context_JSON_Call) Return(err error) *Context_JSON_Call

+ func (_c *Context_JSON_Call) Run(run func(code int, i interface{})) *Context_JSON_Call

+ func (_c *Context_JSON_Call) RunAndReturn(run func(code int, i interface{}) error) *Context_JSON_Call

+ type Context_Logger_Call struct

+ func (_c *Context_Logger_Call) Return(logger echo.Logger) *Context_Logger_Call

+ func (_c *Context_Logger_Call) Run(run func()) *Context_Logger_Call

+ func (_c *Context_Logger_Call) RunAndReturn(run func() echo.Logger) *Context_Logger_Call

+ type Context_MultipartForm_Call struct

+ func (_c *Context_MultipartForm_Call) Return(form *multipart.Form, err error) *Context_MultipartForm_Call

+ func (_c *Context_MultipartForm_Call) Run(run func()) *Context_MultipartForm_Call

+ func (_c *Context_MultipartForm_Call) RunAndReturn(run func() (*multipart.Form, error)) *Context_MultipartForm_Call

+ type Context_NoContent_Call struct

+ func (_c *Context_NoContent_Call) Return(err error) *Context_NoContent_Call

+ func (_c *Context_NoContent_Call) Run(run func(code int)) *Context_NoContent_Call

+ func (_c *Context_NoContent_Call) RunAndReturn(run func(code int) error) *Context_NoContent_Call

+ type Context_ParamNames_Call struct

+ func (_c *Context_ParamNames_Call) Return(strings []string) *Context_ParamNames_Call

+ func (_c *Context_ParamNames_Call) Run(run func()) *Context_ParamNames_Call

+ func (_c *Context_ParamNames_Call) RunAndReturn(run func() []string) *Context_ParamNames_Call

+ type Context_ParamValues_Call struct

+ func (_c *Context_ParamValues_Call) Return(strings []string) *Context_ParamValues_Call

+ func (_c *Context_ParamValues_Call) Run(run func()) *Context_ParamValues_Call

+ func (_c *Context_ParamValues_Call) RunAndReturn(run func() []string) *Context_ParamValues_Call

+ type Context_Param_Call struct

+ func (_c *Context_Param_Call) Return(s string) *Context_Param_Call

+ func (_c *Context_Param_Call) Run(run func(name string)) *Context_Param_Call

+ func (_c *Context_Param_Call) RunAndReturn(run func(name string) string) *Context_Param_Call

+ type Context_Path_Call struct

+ func (_c *Context_Path_Call) Return(s string) *Context_Path_Call

+ func (_c *Context_Path_Call) Run(run func()) *Context_Path_Call

+ func (_c *Context_Path_Call) RunAndReturn(run func() string) *Context_Path_Call

+ type Context_QueryParam_Call struct

+ func (_c *Context_QueryParam_Call) Return(s string) *Context_QueryParam_Call

+ func (_c *Context_QueryParam_Call) Run(run func(name string)) *Context_QueryParam_Call

+ func (_c *Context_QueryParam_Call) RunAndReturn(run func(name string) string) *Context_QueryParam_Call

+ type Context_QueryParams_Call struct

+ func (_c *Context_QueryParams_Call) Return(values url.Values) *Context_QueryParams_Call

+ func (_c *Context_QueryParams_Call) Run(run func()) *Context_QueryParams_Call

+ func (_c *Context_QueryParams_Call) RunAndReturn(run func() url.Values) *Context_QueryParams_Call

+ type Context_QueryString_Call struct

+ func (_c *Context_QueryString_Call) Return(s string) *Context_QueryString_Call

+ func (_c *Context_QueryString_Call) Run(run func()) *Context_QueryString_Call

+ func (_c *Context_QueryString_Call) RunAndReturn(run func() string) *Context_QueryString_Call

+ type Context_RealIP_Call struct

+ func (_c *Context_RealIP_Call) Return(s string) *Context_RealIP_Call

+ func (_c *Context_RealIP_Call) Run(run func()) *Context_RealIP_Call

+ func (_c *Context_RealIP_Call) RunAndReturn(run func() string) *Context_RealIP_Call

+ type Context_Redirect_Call struct

+ func (_c *Context_Redirect_Call) Return(err error) *Context_Redirect_Call

+ func (_c *Context_Redirect_Call) Run(run func(code int, url1 string)) *Context_Redirect_Call

+ func (_c *Context_Redirect_Call) RunAndReturn(run func(code int, url1 string) error) *Context_Redirect_Call

+ type Context_Render_Call struct

+ func (_c *Context_Render_Call) Return(err error) *Context_Render_Call

+ func (_c *Context_Render_Call) Run(run func(code int, name string, data interface{})) *Context_Render_Call

+ func (_c *Context_Render_Call) RunAndReturn(run func(code int, name string, data interface{}) error) *Context_Render_Call

+ type Context_Request_Call struct

+ func (_c *Context_Request_Call) Return(request *http.Request) *Context_Request_Call

+ func (_c *Context_Request_Call) Run(run func()) *Context_Request_Call

+ func (_c *Context_Request_Call) RunAndReturn(run func() *http.Request) *Context_Request_Call

+ type Context_Reset_Call struct

+ func (_c *Context_Reset_Call) Return() *Context_Reset_Call

+ func (_c *Context_Reset_Call) Run(run func(r *http.Request, w http.ResponseWriter)) *Context_Reset_Call

+ func (_c *Context_Reset_Call) RunAndReturn(run func(r *http.Request, w http.ResponseWriter)) *Context_Reset_Call

+ type Context_Response_Call struct

+ func (_c *Context_Response_Call) Return(response *echo.Response) *Context_Response_Call

+ func (_c *Context_Response_Call) Run(run func()) *Context_Response_Call

+ func (_c *Context_Response_Call) RunAndReturn(run func() *echo.Response) *Context_Response_Call

+ type Context_Scheme_Call struct

+ func (_c *Context_Scheme_Call) Return(s string) *Context_Scheme_Call

+ func (_c *Context_Scheme_Call) Run(run func()) *Context_Scheme_Call

+ func (_c *Context_Scheme_Call) RunAndReturn(run func() string) *Context_Scheme_Call

+ type Context_SetCookie_Call struct

+ func (_c *Context_SetCookie_Call) Return() *Context_SetCookie_Call

+ func (_c *Context_SetCookie_Call) Run(run func(cookie *http.Cookie)) *Context_SetCookie_Call

+ func (_c *Context_SetCookie_Call) RunAndReturn(run func(cookie *http.Cookie)) *Context_SetCookie_Call

+ type Context_SetHandler_Call struct

+ func (_c *Context_SetHandler_Call) Return() *Context_SetHandler_Call

+ func (_c *Context_SetHandler_Call) Run(run func(h echo.HandlerFunc)) *Context_SetHandler_Call

+ func (_c *Context_SetHandler_Call) RunAndReturn(run func(h echo.HandlerFunc)) *Context_SetHandler_Call

+ type Context_SetLogger_Call struct

+ func (_c *Context_SetLogger_Call) Return() *Context_SetLogger_Call

+ func (_c *Context_SetLogger_Call) Run(run func(l echo.Logger)) *Context_SetLogger_Call

+ func (_c *Context_SetLogger_Call) RunAndReturn(run func(l echo.Logger)) *Context_SetLogger_Call

+ type Context_SetParamNames_Call struct

+ func (_c *Context_SetParamNames_Call) Return() *Context_SetParamNames_Call

+ func (_c *Context_SetParamNames_Call) Run(run func(names ...string)) *Context_SetParamNames_Call

+ func (_c *Context_SetParamNames_Call) RunAndReturn(run func(names ...string)) *Context_SetParamNames_Call

+ type Context_SetParamValues_Call struct

+ func (_c *Context_SetParamValues_Call) Return() *Context_SetParamValues_Call

+ func (_c *Context_SetParamValues_Call) Run(run func(values ...string)) *Context_SetParamValues_Call

+ func (_c *Context_SetParamValues_Call) RunAndReturn(run func(values ...string)) *Context_SetParamValues_Call

+ type Context_SetPath_Call struct

+ func (_c *Context_SetPath_Call) Return() *Context_SetPath_Call

+ func (_c *Context_SetPath_Call) Run(run func(p string)) *Context_SetPath_Call

+ func (_c *Context_SetPath_Call) RunAndReturn(run func(p string)) *Context_SetPath_Call

+ type Context_SetRequest_Call struct

+ func (_c *Context_SetRequest_Call) Return() *Context_SetRequest_Call

+ func (_c *Context_SetRequest_Call) Run(run func(r *http.Request)) *Context_SetRequest_Call

+ func (_c *Context_SetRequest_Call) RunAndReturn(run func(r *http.Request)) *Context_SetRequest_Call

+ type Context_SetResponse_Call struct

+ func (_c *Context_SetResponse_Call) Return() *Context_SetResponse_Call

+ func (_c *Context_SetResponse_Call) Run(run func(r *echo.Response)) *Context_SetResponse_Call

+ func (_c *Context_SetResponse_Call) RunAndReturn(run func(r *echo.Response)) *Context_SetResponse_Call

+ type Context_Set_Call struct

+ func (_c *Context_Set_Call) Return() *Context_Set_Call

+ func (_c *Context_Set_Call) Run(run func(key string, val interface{})) *Context_Set_Call

+ func (_c *Context_Set_Call) RunAndReturn(run func(key string, val interface{})) *Context_Set_Call

+ type Context_Stream_Call struct

+ func (_c *Context_Stream_Call) Return(err error) *Context_Stream_Call

+ func (_c *Context_Stream_Call) Run(run func(code int, contentType string, r io.Reader)) *Context_Stream_Call

+ func (_c *Context_Stream_Call) RunAndReturn(run func(code int, contentType string, r io.Reader) error) *Context_Stream_Call

+ type Context_String_Call struct

+ func (_c *Context_String_Call) Return(err error) *Context_String_Call

+ func (_c *Context_String_Call) Run(run func(code int, s string)) *Context_String_Call

+ func (_c *Context_String_Call) RunAndReturn(run func(code int, s string) error) *Context_String_Call

+ type Context_Validate_Call struct

+ func (_c *Context_Validate_Call) Return(err error) *Context_Validate_Call

+ func (_c *Context_Validate_Call) Run(run func(i interface{})) *Context_Validate_Call

+ func (_c *Context_Validate_Call) RunAndReturn(run func(i interface{}) error) *Context_Validate_Call

+ type Context_XMLBlob_Call struct

+ func (_c *Context_XMLBlob_Call) Return(err error) *Context_XMLBlob_Call

+ func (_c *Context_XMLBlob_Call) Run(run func(code int, b []byte)) *Context_XMLBlob_Call

+ func (_c *Context_XMLBlob_Call) RunAndReturn(run func(code int, b []byte) error) *Context_XMLBlob_Call

+ type Context_XMLPretty_Call struct

+ func (_c *Context_XMLPretty_Call) Return(err error) *Context_XMLPretty_Call

+ func (_c *Context_XMLPretty_Call) Run(run func(code int, i interface{}, indent string)) *Context_XMLPretty_Call

+ func (_c *Context_XMLPretty_Call) RunAndReturn(run func(code int, i interface{}, indent string) error) *Context_XMLPretty_Call

+ type Context_XML_Call struct

+ func (_c *Context_XML_Call) Return(err error) *Context_XML_Call

+ func (_c *Context_XML_Call) Run(run func(code int, i interface{})) *Context_XML_Call

+ func (_c *Context_XML_Call) RunAndReturn(run func(code int, i interface{}) error) *Context_XML_Call

+ type CveRepository struct

+ func NewCveRepository(t interface{ ... }) *CveRepository

+ func (_m *CveRepository) EXPECT() *CveRepository_Expecter

+ func (_mock *CveRepository) Activate(tx core.DB, id string) error

+ func (_mock *CveRepository) All() ([]models.CVE, error)

+ func (_mock *CveRepository) Begin() core.DB

+ func (_mock *CveRepository) Create(tx core.DB, t *models.CVE) error

+ func (_mock *CveRepository) CreateBatch(tx core.DB, ts []models.CVE) error

+ func (_mock *CveRepository) Delete(tx core.DB, id string) error

+ func (_mock *CveRepository) DeleteBatch(tx core.DB, ids []models.CVE) error

+ func (_mock *CveRepository) FindAllListPaged(tx core.DB, pageInfo core.PageInfo, filter []core.FilterQuery, ...) (core.Paged[models.CVE], error)

+ func (_mock *CveRepository) FindByID(id string) (models.CVE, error)

+ func (_mock *CveRepository) FindCVE(tx core.DB, id string) (models.CVE, error)

+ func (_mock *CveRepository) FindCVEs(tx core.DB, ids []string) ([]models.CVE, error)

+ func (_mock *CveRepository) GetAllCVEsID() ([]string, error)

+ func (_mock *CveRepository) GetDB(tx core.DB) core.DB

+ func (_mock *CveRepository) GetLastModDate() (time.Time, error)

+ func (_mock *CveRepository) List(ids []string) ([]models.CVE, error)

+ func (_mock *CveRepository) Read(id string) (models.CVE, error)

+ func (_mock *CveRepository) Save(tx core.DB, cve *models.CVE) error

+ func (_mock *CveRepository) SaveBatch(tx core.DB, ts []models.CVE) error

+ func (_mock *CveRepository) SaveCveAffectedComponents(tx core.DB, cveID string, affectedComponentHashes []string) error

+ func (_mock *CveRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *CveRepository) Upsert(t *[]*models.CVE, conflictingColumns []clause.Column, updateOnly []string) error

+ type CveRepository_Activate_Call struct

+ func (_c *CveRepository_Activate_Call) Return(err error) *CveRepository_Activate_Call

+ func (_c *CveRepository_Activate_Call) Run(run func(tx core.DB, id string)) *CveRepository_Activate_Call

+ func (_c *CveRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *CveRepository_Activate_Call

+ type CveRepository_All_Call struct

+ func (_c *CveRepository_All_Call) Return(cVEs []models.CVE, err error) *CveRepository_All_Call

+ func (_c *CveRepository_All_Call) Run(run func()) *CveRepository_All_Call

+ func (_c *CveRepository_All_Call) RunAndReturn(run func() ([]models.CVE, error)) *CveRepository_All_Call

+ type CveRepository_Begin_Call struct

+ func (_c *CveRepository_Begin_Call) Return(v core.DB) *CveRepository_Begin_Call

+ func (_c *CveRepository_Begin_Call) Run(run func()) *CveRepository_Begin_Call

+ func (_c *CveRepository_Begin_Call) RunAndReturn(run func() core.DB) *CveRepository_Begin_Call

+ type CveRepository_CreateBatch_Call struct

+ func (_c *CveRepository_CreateBatch_Call) Return(err error) *CveRepository_CreateBatch_Call

+ func (_c *CveRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.CVE)) *CveRepository_CreateBatch_Call

+ func (_c *CveRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.CVE) error) *CveRepository_CreateBatch_Call

+ type CveRepository_Create_Call struct

+ func (_c *CveRepository_Create_Call) Return(err error) *CveRepository_Create_Call

+ func (_c *CveRepository_Create_Call) Run(run func(tx core.DB, t *models.CVE)) *CveRepository_Create_Call

+ func (_c *CveRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.CVE) error) *CveRepository_Create_Call

+ type CveRepository_DeleteBatch_Call struct

+ func (_c *CveRepository_DeleteBatch_Call) Return(err error) *CveRepository_DeleteBatch_Call

+ func (_c *CveRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.CVE)) *CveRepository_DeleteBatch_Call

+ func (_c *CveRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.CVE) error) *CveRepository_DeleteBatch_Call

+ type CveRepository_Delete_Call struct

+ func (_c *CveRepository_Delete_Call) Return(err error) *CveRepository_Delete_Call

+ func (_c *CveRepository_Delete_Call) Run(run func(tx core.DB, id string)) *CveRepository_Delete_Call

+ func (_c *CveRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *CveRepository_Delete_Call

+ type CveRepository_Expecter struct

+ func (_e *CveRepository_Expecter) Activate(tx interface{}, id interface{}) *CveRepository_Activate_Call

+ func (_e *CveRepository_Expecter) All() *CveRepository_All_Call

+ func (_e *CveRepository_Expecter) Begin() *CveRepository_Begin_Call

+ func (_e *CveRepository_Expecter) Create(tx interface{}, t interface{}) *CveRepository_Create_Call

+ func (_e *CveRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *CveRepository_CreateBatch_Call

+ func (_e *CveRepository_Expecter) Delete(tx interface{}, id interface{}) *CveRepository_Delete_Call

+ func (_e *CveRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *CveRepository_DeleteBatch_Call

+ func (_e *CveRepository_Expecter) FindAllListPaged(tx interface{}, pageInfo interface{}, filter interface{}, sort interface{}) *CveRepository_FindAllListPaged_Call

+ func (_e *CveRepository_Expecter) FindByID(id interface{}) *CveRepository_FindByID_Call

+ func (_e *CveRepository_Expecter) FindCVE(tx interface{}, id interface{}) *CveRepository_FindCVE_Call

+ func (_e *CveRepository_Expecter) FindCVEs(tx interface{}, ids interface{}) *CveRepository_FindCVEs_Call

+ func (_e *CveRepository_Expecter) GetAllCVEsID() *CveRepository_GetAllCVEsID_Call

+ func (_e *CveRepository_Expecter) GetDB(tx interface{}) *CveRepository_GetDB_Call

+ func (_e *CveRepository_Expecter) GetLastModDate() *CveRepository_GetLastModDate_Call

+ func (_e *CveRepository_Expecter) List(ids interface{}) *CveRepository_List_Call

+ func (_e *CveRepository_Expecter) Read(id interface{}) *CveRepository_Read_Call

+ func (_e *CveRepository_Expecter) Save(tx interface{}, cve interface{}) *CveRepository_Save_Call

+ func (_e *CveRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *CveRepository_SaveBatch_Call

+ func (_e *CveRepository_Expecter) SaveCveAffectedComponents(tx interface{}, cveID interface{}, affectedComponentHashes interface{}) *CveRepository_SaveCveAffectedComponents_Call

+ func (_e *CveRepository_Expecter) Transaction(fn interface{}) *CveRepository_Transaction_Call

+ func (_e *CveRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *CveRepository_Upsert_Call

+ type CveRepository_FindAllListPaged_Call struct

+ func (_c *CveRepository_FindAllListPaged_Call) Return(paged core.Paged[models.CVE], err error) *CveRepository_FindAllListPaged_Call

+ func (_c *CveRepository_FindAllListPaged_Call) Run(run func(tx core.DB, pageInfo core.PageInfo, filter []core.FilterQuery, ...)) *CveRepository_FindAllListPaged_Call

+ func (_c *CveRepository_FindAllListPaged_Call) RunAndReturn(...) *CveRepository_FindAllListPaged_Call

+ type CveRepository_FindByID_Call struct

+ func (_c *CveRepository_FindByID_Call) Return(cVE models.CVE, err error) *CveRepository_FindByID_Call

+ func (_c *CveRepository_FindByID_Call) Run(run func(id string)) *CveRepository_FindByID_Call

+ func (_c *CveRepository_FindByID_Call) RunAndReturn(run func(id string) (models.CVE, error)) *CveRepository_FindByID_Call

+ type CveRepository_FindCVE_Call struct

+ func (_c *CveRepository_FindCVE_Call) Return(cVE models.CVE, err error) *CveRepository_FindCVE_Call

+ func (_c *CveRepository_FindCVE_Call) Run(run func(tx core.DB, id string)) *CveRepository_FindCVE_Call

+ func (_c *CveRepository_FindCVE_Call) RunAndReturn(run func(tx core.DB, id string) (models.CVE, error)) *CveRepository_FindCVE_Call

+ type CveRepository_FindCVEs_Call struct

+ func (_c *CveRepository_FindCVEs_Call) Return(cVEs []models.CVE, err error) *CveRepository_FindCVEs_Call

+ func (_c *CveRepository_FindCVEs_Call) Run(run func(tx core.DB, ids []string)) *CveRepository_FindCVEs_Call

+ func (_c *CveRepository_FindCVEs_Call) RunAndReturn(run func(tx core.DB, ids []string) ([]models.CVE, error)) *CveRepository_FindCVEs_Call

+ type CveRepository_GetAllCVEsID_Call struct

+ func (_c *CveRepository_GetAllCVEsID_Call) Return(strings []string, err error) *CveRepository_GetAllCVEsID_Call

+ func (_c *CveRepository_GetAllCVEsID_Call) Run(run func()) *CveRepository_GetAllCVEsID_Call

+ func (_c *CveRepository_GetAllCVEsID_Call) RunAndReturn(run func() ([]string, error)) *CveRepository_GetAllCVEsID_Call

+ type CveRepository_GetDB_Call struct

+ func (_c *CveRepository_GetDB_Call) Return(v core.DB) *CveRepository_GetDB_Call

+ func (_c *CveRepository_GetDB_Call) Run(run func(tx core.DB)) *CveRepository_GetDB_Call

+ func (_c *CveRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *CveRepository_GetDB_Call

+ type CveRepository_GetLastModDate_Call struct

+ func (_c *CveRepository_GetLastModDate_Call) Return(time1 time.Time, err error) *CveRepository_GetLastModDate_Call

+ func (_c *CveRepository_GetLastModDate_Call) Run(run func()) *CveRepository_GetLastModDate_Call

+ func (_c *CveRepository_GetLastModDate_Call) RunAndReturn(run func() (time.Time, error)) *CveRepository_GetLastModDate_Call

+ type CveRepository_List_Call struct

+ func (_c *CveRepository_List_Call) Return(cVEs []models.CVE, err error) *CveRepository_List_Call

+ func (_c *CveRepository_List_Call) Run(run func(ids []string)) *CveRepository_List_Call

+ func (_c *CveRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.CVE, error)) *CveRepository_List_Call

+ type CveRepository_Read_Call struct

+ func (_c *CveRepository_Read_Call) Return(cVE models.CVE, err error) *CveRepository_Read_Call

+ func (_c *CveRepository_Read_Call) Run(run func(id string)) *CveRepository_Read_Call

+ func (_c *CveRepository_Read_Call) RunAndReturn(run func(id string) (models.CVE, error)) *CveRepository_Read_Call

+ type CveRepository_SaveBatch_Call struct

+ func (_c *CveRepository_SaveBatch_Call) Return(err error) *CveRepository_SaveBatch_Call

+ func (_c *CveRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.CVE)) *CveRepository_SaveBatch_Call

+ func (_c *CveRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.CVE) error) *CveRepository_SaveBatch_Call

+ type CveRepository_SaveCveAffectedComponents_Call struct

+ func (_c *CveRepository_SaveCveAffectedComponents_Call) Return(err error) *CveRepository_SaveCveAffectedComponents_Call

+ func (_c *CveRepository_SaveCveAffectedComponents_Call) Run(run func(tx core.DB, cveID string, affectedComponentHashes []string)) *CveRepository_SaveCveAffectedComponents_Call

+ func (_c *CveRepository_SaveCveAffectedComponents_Call) RunAndReturn(run func(tx core.DB, cveID string, affectedComponentHashes []string) error) *CveRepository_SaveCveAffectedComponents_Call

+ type CveRepository_Save_Call struct

+ func (_c *CveRepository_Save_Call) Return(err error) *CveRepository_Save_Call

+ func (_c *CveRepository_Save_Call) Run(run func(tx core.DB, cve *models.CVE)) *CveRepository_Save_Call

+ func (_c *CveRepository_Save_Call) RunAndReturn(run func(tx core.DB, cve *models.CVE) error) *CveRepository_Save_Call

+ type CveRepository_Transaction_Call struct

+ func (_c *CveRepository_Transaction_Call) Return(err error) *CveRepository_Transaction_Call

+ func (_c *CveRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *CveRepository_Transaction_Call

+ func (_c *CveRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *CveRepository_Transaction_Call

+ type CveRepository_Upsert_Call struct

+ func (_c *CveRepository_Upsert_Call) Return(err error) *CveRepository_Upsert_Call

+ func (_c *CveRepository_Upsert_Call) Run(...) *CveRepository_Upsert_Call

+ func (_c *CveRepository_Upsert_Call) RunAndReturn(...) *CveRepository_Upsert_Call

+ type CvssInterface struct

+ func NewCvssInterface(t interface{ ... }) *CvssInterface

+ func (_m *CvssInterface) EXPECT() *CvssInterface_Expecter

+ func (_mock *CvssInterface) EnvironmentalScore() float64

+ func (_mock *CvssInterface) Get(key string) (string, error)

+ func (_mock *CvssInterface) Set(key string, value string) error

+ func (_mock *CvssInterface) TemporalScore() float64

+ func (_mock *CvssInterface) Vector() string

+ type CvssInterface_EnvironmentalScore_Call struct

+ func (_c *CvssInterface_EnvironmentalScore_Call) Return(f float64) *CvssInterface_EnvironmentalScore_Call

+ func (_c *CvssInterface_EnvironmentalScore_Call) Run(run func()) *CvssInterface_EnvironmentalScore_Call

+ func (_c *CvssInterface_EnvironmentalScore_Call) RunAndReturn(run func() float64) *CvssInterface_EnvironmentalScore_Call

+ type CvssInterface_Expecter struct

+ func (_e *CvssInterface_Expecter) EnvironmentalScore() *CvssInterface_EnvironmentalScore_Call

+ func (_e *CvssInterface_Expecter) Get(key interface{}) *CvssInterface_Get_Call

+ func (_e *CvssInterface_Expecter) Set(key interface{}, value interface{}) *CvssInterface_Set_Call

+ func (_e *CvssInterface_Expecter) TemporalScore() *CvssInterface_TemporalScore_Call

+ func (_e *CvssInterface_Expecter) Vector() *CvssInterface_Vector_Call

+ type CvssInterface_Get_Call struct

+ func (_c *CvssInterface_Get_Call) Return(s string, err error) *CvssInterface_Get_Call

+ func (_c *CvssInterface_Get_Call) Run(run func(key string)) *CvssInterface_Get_Call

+ func (_c *CvssInterface_Get_Call) RunAndReturn(run func(key string) (string, error)) *CvssInterface_Get_Call

+ type CvssInterface_Set_Call struct

+ func (_c *CvssInterface_Set_Call) Return(err error) *CvssInterface_Set_Call

+ func (_c *CvssInterface_Set_Call) Run(run func(key string, value string)) *CvssInterface_Set_Call

+ func (_c *CvssInterface_Set_Call) RunAndReturn(run func(key string, value string) error) *CvssInterface_Set_Call

+ type CvssInterface_TemporalScore_Call struct

+ func (_c *CvssInterface_TemporalScore_Call) Return(f float64) *CvssInterface_TemporalScore_Call

+ func (_c *CvssInterface_TemporalScore_Call) Run(run func()) *CvssInterface_TemporalScore_Call

+ func (_c *CvssInterface_TemporalScore_Call) RunAndReturn(run func() float64) *CvssInterface_TemporalScore_Call

+ type CvssInterface_Vector_Call struct

+ func (_c *CvssInterface_Vector_Call) Return(s string) *CvssInterface_Vector_Call

+ func (_c *CvssInterface_Vector_Call) Run(run func()) *CvssInterface_Vector_Call

+ func (_c *CvssInterface_Vector_Call) RunAndReturn(run func() string) *CvssInterface_Vector_Call

+ type CweRepository struct

+ func NewCweRepository(t interface{ ... }) *CweRepository

+ func (_m *CweRepository) EXPECT() *CweRepository_Expecter

+ func (_mock *CweRepository) GetAllCWEsID() ([]string, error)

+ func (_mock *CweRepository) SaveBatch(tx core.DB, cwes []models.CWE) error

+ type CweRepository_Expecter struct

+ func (_e *CweRepository_Expecter) GetAllCWEsID() *CweRepository_GetAllCWEsID_Call

+ func (_e *CweRepository_Expecter) SaveBatch(tx interface{}, cwes interface{}) *CweRepository_SaveBatch_Call

+ type CweRepository_GetAllCWEsID_Call struct

+ func (_c *CweRepository_GetAllCWEsID_Call) Return(strings []string, err error) *CweRepository_GetAllCWEsID_Call

+ func (_c *CweRepository_GetAllCWEsID_Call) Run(run func()) *CweRepository_GetAllCWEsID_Call

+ func (_c *CweRepository_GetAllCWEsID_Call) RunAndReturn(run func() ([]string, error)) *CweRepository_GetAllCWEsID_Call

+ type CweRepository_SaveBatch_Call struct

+ func (_c *CweRepository_SaveBatch_Call) Return(err error) *CweRepository_SaveBatch_Call

+ func (_c *CweRepository_SaveBatch_Call) Run(run func(tx core.DB, cwes []models.CWE)) *CweRepository_SaveBatch_Call

+ func (_c *CweRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, cwes []models.CWE) error) *CweRepository_SaveBatch_Call

+ type DependencyVulnRepository struct

+ func NewDependencyVulnRepository(t interface{ ... }) *DependencyVulnRepository

+ func (_m *DependencyVulnRepository) EXPECT() *DependencyVulnRepository_Expecter

+ func (_mock *DependencyVulnRepository) Activate(tx core.DB, id string) error

+ func (_mock *DependencyVulnRepository) All() ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) ApplyAndSave(tx core.DB, dependencyVuln *models.DependencyVuln, vulnEvent *models.VulnEvent) error

+ func (_mock *DependencyVulnRepository) Begin() core.DB

+ func (_mock *DependencyVulnRepository) Create(tx core.DB, t *models.DependencyVuln) error

+ func (_mock *DependencyVulnRepository) CreateBatch(tx core.DB, ts []models.DependencyVuln) error

+ func (_mock *DependencyVulnRepository) Delete(tx core.DB, id string) error

+ func (_mock *DependencyVulnRepository) DeleteBatch(tx core.DB, ids []models.DependencyVuln) error

+ func (_mock *DependencyVulnRepository) GetAllByAssetIDAndState(tx core.DB, assetID uuid.UUID, state models.VulnState, ...) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetAllOpenVulnsByAssetVersionNameAndAssetID(tx core.DB, artifactName *string, assetVersionName string, assetID uuid.UUID) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetAllVulnsByAssetID(tx core.DB, assetID uuid.UUID) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetByAssetVersionPaged(tx core.DB, assetVersionName string, assetID uuid.UUID, pageInfo core.PageInfo, ...) (core.Paged[models.DependencyVuln], map[string]int, error)

+ func (_mock *DependencyVulnRepository) GetDB(tx core.DB) core.DB

+ func (_mock *DependencyVulnRepository) GetDefaultDependencyVulnsByOrgIDPaged(tx core.DB, userAllowedProjectIds []string, pageInfo core.PageInfo, ...) (core.Paged[models.DependencyVuln], error)

+ func (_mock *DependencyVulnRepository) GetDefaultDependencyVulnsByProjectIDPaged(tx core.DB, projectID uuid.UUID, pageInfo core.PageInfo, search string, ...) (core.Paged[models.DependencyVuln], error)

+ func (_mock *DependencyVulnRepository) GetDependencyVulnsByAssetVersion(tx core.DB, assetVersionName string, assetID uuid.UUID, artifactName *string) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetDependencyVulnsByAssetVersionPagedAndFlat(tx core.DB, assetVersionName string, assetVersionID uuid.UUID, ...) (core.Paged[models.DependencyVuln], error)

+ func (_mock *DependencyVulnRepository) GetDependencyVulnsByDefaultAssetVersion(tx core.DB, assetID uuid.UUID, artifactName *string) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetDependencyVulnsByOtherAssetVersions(tx core.DB, assetVersionName string, assetID uuid.UUID) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetDependencyVulnsByPurl(tx core.DB, purls []string) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) GetHintsInOrganizationForVuln(tx core.DB, orgID uuid.UUID, pURL string, cveID string) (common.DependencyVulnHints, error)

+ func (_mock *DependencyVulnRepository) List(ids []string) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) ListByAssetAndAssetVersion(assetVersionName string, assetID uuid.UUID) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) ListUnfixedByAssetAndAssetVersion(assetVersionName string, assetID uuid.UUID, artifactName *string) ([]models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) Read(id string) (models.DependencyVuln, error)

+ func (_mock *DependencyVulnRepository) Save(tx core.DB, t *models.DependencyVuln) error

+ func (_mock *DependencyVulnRepository) SaveBatch(tx core.DB, ts []models.DependencyVuln) error

+ func (_mock *DependencyVulnRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *DependencyVulnRepository) Upsert(t *[]*models.DependencyVuln, conflictingColumns []clause.Column, ...) error

+ type DependencyVulnRepository_Activate_Call struct

+ func (_c *DependencyVulnRepository_Activate_Call) Return(err error) *DependencyVulnRepository_Activate_Call

+ func (_c *DependencyVulnRepository_Activate_Call) Run(run func(tx core.DB, id string)) *DependencyVulnRepository_Activate_Call

+ func (_c *DependencyVulnRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *DependencyVulnRepository_Activate_Call

+ type DependencyVulnRepository_All_Call struct

+ func (_c *DependencyVulnRepository_All_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_All_Call

+ func (_c *DependencyVulnRepository_All_Call) Run(run func()) *DependencyVulnRepository_All_Call

+ func (_c *DependencyVulnRepository_All_Call) RunAndReturn(run func() ([]models.DependencyVuln, error)) *DependencyVulnRepository_All_Call

+ type DependencyVulnRepository_ApplyAndSave_Call struct

+ func (_c *DependencyVulnRepository_ApplyAndSave_Call) Return(err error) *DependencyVulnRepository_ApplyAndSave_Call

+ func (_c *DependencyVulnRepository_ApplyAndSave_Call) Run(...) *DependencyVulnRepository_ApplyAndSave_Call

+ func (_c *DependencyVulnRepository_ApplyAndSave_Call) RunAndReturn(...) *DependencyVulnRepository_ApplyAndSave_Call

+ type DependencyVulnRepository_Begin_Call struct

+ func (_c *DependencyVulnRepository_Begin_Call) Return(v core.DB) *DependencyVulnRepository_Begin_Call

+ func (_c *DependencyVulnRepository_Begin_Call) Run(run func()) *DependencyVulnRepository_Begin_Call

+ func (_c *DependencyVulnRepository_Begin_Call) RunAndReturn(run func() core.DB) *DependencyVulnRepository_Begin_Call

+ type DependencyVulnRepository_CreateBatch_Call struct

+ func (_c *DependencyVulnRepository_CreateBatch_Call) Return(err error) *DependencyVulnRepository_CreateBatch_Call

+ func (_c *DependencyVulnRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.DependencyVuln)) *DependencyVulnRepository_CreateBatch_Call

+ func (_c *DependencyVulnRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.DependencyVuln) error) *DependencyVulnRepository_CreateBatch_Call

+ type DependencyVulnRepository_Create_Call struct

+ func (_c *DependencyVulnRepository_Create_Call) Return(err error) *DependencyVulnRepository_Create_Call

+ func (_c *DependencyVulnRepository_Create_Call) Run(run func(tx core.DB, t *models.DependencyVuln)) *DependencyVulnRepository_Create_Call

+ func (_c *DependencyVulnRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.DependencyVuln) error) *DependencyVulnRepository_Create_Call

+ type DependencyVulnRepository_DeleteBatch_Call struct

+ func (_c *DependencyVulnRepository_DeleteBatch_Call) Return(err error) *DependencyVulnRepository_DeleteBatch_Call

+ func (_c *DependencyVulnRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.DependencyVuln)) *DependencyVulnRepository_DeleteBatch_Call

+ func (_c *DependencyVulnRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.DependencyVuln) error) *DependencyVulnRepository_DeleteBatch_Call

+ type DependencyVulnRepository_Delete_Call struct

+ func (_c *DependencyVulnRepository_Delete_Call) Return(err error) *DependencyVulnRepository_Delete_Call

+ func (_c *DependencyVulnRepository_Delete_Call) Run(run func(tx core.DB, id string)) *DependencyVulnRepository_Delete_Call

+ func (_c *DependencyVulnRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *DependencyVulnRepository_Delete_Call

+ type DependencyVulnRepository_Expecter struct

+ func (_e *DependencyVulnRepository_Expecter) Activate(tx interface{}, id interface{}) *DependencyVulnRepository_Activate_Call

+ func (_e *DependencyVulnRepository_Expecter) All() *DependencyVulnRepository_All_Call

+ func (_e *DependencyVulnRepository_Expecter) ApplyAndSave(tx interface{}, dependencyVuln interface{}, vulnEvent interface{}) *DependencyVulnRepository_ApplyAndSave_Call

+ func (_e *DependencyVulnRepository_Expecter) Begin() *DependencyVulnRepository_Begin_Call

+ func (_e *DependencyVulnRepository_Expecter) Create(tx interface{}, t interface{}) *DependencyVulnRepository_Create_Call

+ func (_e *DependencyVulnRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *DependencyVulnRepository_CreateBatch_Call

+ func (_e *DependencyVulnRepository_Expecter) Delete(tx interface{}, id interface{}) *DependencyVulnRepository_Delete_Call

+ func (_e *DependencyVulnRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *DependencyVulnRepository_DeleteBatch_Call

+ func (_e *DependencyVulnRepository_Expecter) GetAllByAssetIDAndState(tx interface{}, assetID interface{}, state interface{}, ...) *DependencyVulnRepository_GetAllByAssetIDAndState_Call

+ func (_e *DependencyVulnRepository_Expecter) GetAllOpenVulnsByAssetVersionNameAndAssetID(tx interface{}, artifactName interface{}, assetVersionName interface{}, ...) *DependencyVulnRepository_GetAllOpenVulnsByAssetVersionNameAndAssetID_Call

+ func (_e *DependencyVulnRepository_Expecter) GetAllVulnsByAssetID(tx interface{}, assetID interface{}) *DependencyVulnRepository_GetAllVulnsByAssetID_Call

+ func (_e *DependencyVulnRepository_Expecter) GetByAssetVersionPaged(tx interface{}, assetVersionName interface{}, assetID interface{}, ...) *DependencyVulnRepository_GetByAssetVersionPaged_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDB(tx interface{}) *DependencyVulnRepository_GetDB_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDefaultDependencyVulnsByOrgIDPaged(tx interface{}, userAllowedProjectIds interface{}, pageInfo interface{}, ...) *DependencyVulnRepository_GetDefaultDependencyVulnsByOrgIDPaged_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDefaultDependencyVulnsByProjectIDPaged(tx interface{}, projectID interface{}, pageInfo interface{}, ...) *DependencyVulnRepository_GetDefaultDependencyVulnsByProjectIDPaged_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDependencyVulnsByAssetVersion(tx interface{}, assetVersionName interface{}, assetID interface{}, ...) *DependencyVulnRepository_GetDependencyVulnsByAssetVersion_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDependencyVulnsByAssetVersionPagedAndFlat(tx interface{}, assetVersionName interface{}, assetVersionID interface{}, ...) *DependencyVulnRepository_GetDependencyVulnsByAssetVersionPagedAndFlat_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDependencyVulnsByDefaultAssetVersion(tx interface{}, assetID interface{}, artifactName interface{}) *DependencyVulnRepository_GetDependencyVulnsByDefaultAssetVersion_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDependencyVulnsByOtherAssetVersions(tx interface{}, assetVersionName interface{}, assetID interface{}) *DependencyVulnRepository_GetDependencyVulnsByOtherAssetVersions_Call

+ func (_e *DependencyVulnRepository_Expecter) GetDependencyVulnsByPurl(tx interface{}, purls interface{}) *DependencyVulnRepository_GetDependencyVulnsByPurl_Call

+ func (_e *DependencyVulnRepository_Expecter) GetHintsInOrganizationForVuln(tx interface{}, orgID interface{}, pURL interface{}, cveID interface{}) *DependencyVulnRepository_GetHintsInOrganizationForVuln_Call

+ func (_e *DependencyVulnRepository_Expecter) List(ids interface{}) *DependencyVulnRepository_List_Call

+ func (_e *DependencyVulnRepository_Expecter) ListByAssetAndAssetVersion(assetVersionName interface{}, assetID interface{}) *DependencyVulnRepository_ListByAssetAndAssetVersion_Call

+ func (_e *DependencyVulnRepository_Expecter) ListUnfixedByAssetAndAssetVersion(assetVersionName interface{}, assetID interface{}, artifactName interface{}) *DependencyVulnRepository_ListUnfixedByAssetAndAssetVersion_Call

+ func (_e *DependencyVulnRepository_Expecter) Read(id interface{}) *DependencyVulnRepository_Read_Call

+ func (_e *DependencyVulnRepository_Expecter) Save(tx interface{}, t interface{}) *DependencyVulnRepository_Save_Call

+ func (_e *DependencyVulnRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *DependencyVulnRepository_SaveBatch_Call

+ func (_e *DependencyVulnRepository_Expecter) Transaction(fn interface{}) *DependencyVulnRepository_Transaction_Call

+ func (_e *DependencyVulnRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *DependencyVulnRepository_Upsert_Call

+ type DependencyVulnRepository_GetAllByAssetIDAndState_Call struct

+ func (_c *DependencyVulnRepository_GetAllByAssetIDAndState_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetAllByAssetIDAndState_Call

+ func (_c *DependencyVulnRepository_GetAllByAssetIDAndState_Call) Run(run func(tx core.DB, assetID uuid.UUID, state models.VulnState, ...)) *DependencyVulnRepository_GetAllByAssetIDAndState_Call

+ func (_c *DependencyVulnRepository_GetAllByAssetIDAndState_Call) RunAndReturn(...) *DependencyVulnRepository_GetAllByAssetIDAndState_Call

+ type DependencyVulnRepository_GetAllOpenVulnsByAssetVersionNameAndAssetID_Call struct

+ func (_c *DependencyVulnRepository_GetAllOpenVulnsByAssetVersionNameAndAssetID_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetAllOpenVulnsByAssetVersionNameAndAssetID_Call

+ func (_c *DependencyVulnRepository_GetAllOpenVulnsByAssetVersionNameAndAssetID_Call) Run(...) *DependencyVulnRepository_GetAllOpenVulnsByAssetVersionNameAndAssetID_Call

+ func (_c *DependencyVulnRepository_GetAllOpenVulnsByAssetVersionNameAndAssetID_Call) RunAndReturn(...) *DependencyVulnRepository_GetAllOpenVulnsByAssetVersionNameAndAssetID_Call

+ type DependencyVulnRepository_GetAllVulnsByAssetID_Call struct

+ func (_c *DependencyVulnRepository_GetAllVulnsByAssetID_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetAllVulnsByAssetID_Call

+ func (_c *DependencyVulnRepository_GetAllVulnsByAssetID_Call) Run(run func(tx core.DB, assetID uuid.UUID)) *DependencyVulnRepository_GetAllVulnsByAssetID_Call

+ func (_c *DependencyVulnRepository_GetAllVulnsByAssetID_Call) RunAndReturn(run func(tx core.DB, assetID uuid.UUID) ([]models.DependencyVuln, error)) *DependencyVulnRepository_GetAllVulnsByAssetID_Call

+ type DependencyVulnRepository_GetByAssetVersionPaged_Call struct

+ func (_c *DependencyVulnRepository_GetByAssetVersionPaged_Call) Return(paged core.Paged[models.DependencyVuln], stringToInt map[string]int, err error) *DependencyVulnRepository_GetByAssetVersionPaged_Call

+ func (_c *DependencyVulnRepository_GetByAssetVersionPaged_Call) Run(...) *DependencyVulnRepository_GetByAssetVersionPaged_Call

+ func (_c *DependencyVulnRepository_GetByAssetVersionPaged_Call) RunAndReturn(...) *DependencyVulnRepository_GetByAssetVersionPaged_Call

+ type DependencyVulnRepository_GetDB_Call struct

+ func (_c *DependencyVulnRepository_GetDB_Call) Return(v core.DB) *DependencyVulnRepository_GetDB_Call

+ func (_c *DependencyVulnRepository_GetDB_Call) Run(run func(tx core.DB)) *DependencyVulnRepository_GetDB_Call

+ func (_c *DependencyVulnRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *DependencyVulnRepository_GetDB_Call

+ type DependencyVulnRepository_GetDefaultDependencyVulnsByOrgIDPaged_Call struct

+ func (_c *DependencyVulnRepository_GetDefaultDependencyVulnsByOrgIDPaged_Call) Return(paged core.Paged[models.DependencyVuln], err error) *DependencyVulnRepository_GetDefaultDependencyVulnsByOrgIDPaged_Call

+ func (_c *DependencyVulnRepository_GetDefaultDependencyVulnsByOrgIDPaged_Call) Run(...) *DependencyVulnRepository_GetDefaultDependencyVulnsByOrgIDPaged_Call

+ func (_c *DependencyVulnRepository_GetDefaultDependencyVulnsByOrgIDPaged_Call) RunAndReturn(...) *DependencyVulnRepository_GetDefaultDependencyVulnsByOrgIDPaged_Call

+ type DependencyVulnRepository_GetDefaultDependencyVulnsByProjectIDPaged_Call struct

+ func (_c *DependencyVulnRepository_GetDefaultDependencyVulnsByProjectIDPaged_Call) Return(paged core.Paged[models.DependencyVuln], err error) *DependencyVulnRepository_GetDefaultDependencyVulnsByProjectIDPaged_Call

+ func (_c *DependencyVulnRepository_GetDefaultDependencyVulnsByProjectIDPaged_Call) Run(...) *DependencyVulnRepository_GetDefaultDependencyVulnsByProjectIDPaged_Call

+ func (_c *DependencyVulnRepository_GetDefaultDependencyVulnsByProjectIDPaged_Call) RunAndReturn(...) *DependencyVulnRepository_GetDefaultDependencyVulnsByProjectIDPaged_Call

+ type DependencyVulnRepository_GetDependencyVulnsByAssetVersionPagedAndFlat_Call struct

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByAssetVersionPagedAndFlat_Call) Return(paged core.Paged[models.DependencyVuln], err error) *DependencyVulnRepository_GetDependencyVulnsByAssetVersionPagedAndFlat_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByAssetVersionPagedAndFlat_Call) Run(run func(tx core.DB, assetVersionName string, assetVersionID uuid.UUID, ...)) *DependencyVulnRepository_GetDependencyVulnsByAssetVersionPagedAndFlat_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByAssetVersionPagedAndFlat_Call) RunAndReturn(...) *DependencyVulnRepository_GetDependencyVulnsByAssetVersionPagedAndFlat_Call

+ type DependencyVulnRepository_GetDependencyVulnsByAssetVersion_Call struct

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByAssetVersion_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetDependencyVulnsByAssetVersion_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByAssetVersion_Call) Run(...) *DependencyVulnRepository_GetDependencyVulnsByAssetVersion_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByAssetVersion_Call) RunAndReturn(...) *DependencyVulnRepository_GetDependencyVulnsByAssetVersion_Call

+ type DependencyVulnRepository_GetDependencyVulnsByDefaultAssetVersion_Call struct

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByDefaultAssetVersion_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetDependencyVulnsByDefaultAssetVersion_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByDefaultAssetVersion_Call) Run(run func(tx core.DB, assetID uuid.UUID, artifactName *string)) *DependencyVulnRepository_GetDependencyVulnsByDefaultAssetVersion_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByDefaultAssetVersion_Call) RunAndReturn(...) *DependencyVulnRepository_GetDependencyVulnsByDefaultAssetVersion_Call

+ type DependencyVulnRepository_GetDependencyVulnsByOtherAssetVersions_Call struct

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByOtherAssetVersions_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetDependencyVulnsByOtherAssetVersions_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByOtherAssetVersions_Call) Run(run func(tx core.DB, assetVersionName string, assetID uuid.UUID)) *DependencyVulnRepository_GetDependencyVulnsByOtherAssetVersions_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByOtherAssetVersions_Call) RunAndReturn(...) *DependencyVulnRepository_GetDependencyVulnsByOtherAssetVersions_Call

+ type DependencyVulnRepository_GetDependencyVulnsByPurl_Call struct

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByPurl_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_GetDependencyVulnsByPurl_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByPurl_Call) Run(run func(tx core.DB, purls []string)) *DependencyVulnRepository_GetDependencyVulnsByPurl_Call

+ func (_c *DependencyVulnRepository_GetDependencyVulnsByPurl_Call) RunAndReturn(run func(tx core.DB, purls []string) ([]models.DependencyVuln, error)) *DependencyVulnRepository_GetDependencyVulnsByPurl_Call

+ type DependencyVulnRepository_GetHintsInOrganizationForVuln_Call struct

+ func (_c *DependencyVulnRepository_GetHintsInOrganizationForVuln_Call) Return(dependencyVulnHints common.DependencyVulnHints, err error) *DependencyVulnRepository_GetHintsInOrganizationForVuln_Call

+ func (_c *DependencyVulnRepository_GetHintsInOrganizationForVuln_Call) Run(run func(tx core.DB, orgID uuid.UUID, pURL string, cveID string)) *DependencyVulnRepository_GetHintsInOrganizationForVuln_Call

+ func (_c *DependencyVulnRepository_GetHintsInOrganizationForVuln_Call) RunAndReturn(...) *DependencyVulnRepository_GetHintsInOrganizationForVuln_Call

+ type DependencyVulnRepository_ListByAssetAndAssetVersion_Call struct

+ func (_c *DependencyVulnRepository_ListByAssetAndAssetVersion_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_ListByAssetAndAssetVersion_Call

+ func (_c *DependencyVulnRepository_ListByAssetAndAssetVersion_Call) Run(run func(assetVersionName string, assetID uuid.UUID)) *DependencyVulnRepository_ListByAssetAndAssetVersion_Call

+ func (_c *DependencyVulnRepository_ListByAssetAndAssetVersion_Call) RunAndReturn(...) *DependencyVulnRepository_ListByAssetAndAssetVersion_Call

+ type DependencyVulnRepository_ListUnfixedByAssetAndAssetVersion_Call struct

+ func (_c *DependencyVulnRepository_ListUnfixedByAssetAndAssetVersion_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_ListUnfixedByAssetAndAssetVersion_Call

+ func (_c *DependencyVulnRepository_ListUnfixedByAssetAndAssetVersion_Call) Run(run func(assetVersionName string, assetID uuid.UUID, artifactName *string)) *DependencyVulnRepository_ListUnfixedByAssetAndAssetVersion_Call

+ func (_c *DependencyVulnRepository_ListUnfixedByAssetAndAssetVersion_Call) RunAndReturn(...) *DependencyVulnRepository_ListUnfixedByAssetAndAssetVersion_Call

+ type DependencyVulnRepository_List_Call struct

+ func (_c *DependencyVulnRepository_List_Call) Return(dependencyVulns []models.DependencyVuln, err error) *DependencyVulnRepository_List_Call

+ func (_c *DependencyVulnRepository_List_Call) Run(run func(ids []string)) *DependencyVulnRepository_List_Call

+ func (_c *DependencyVulnRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.DependencyVuln, error)) *DependencyVulnRepository_List_Call

+ type DependencyVulnRepository_Read_Call struct

+ func (_c *DependencyVulnRepository_Read_Call) Return(dependencyVuln models.DependencyVuln, err error) *DependencyVulnRepository_Read_Call

+ func (_c *DependencyVulnRepository_Read_Call) Run(run func(id string)) *DependencyVulnRepository_Read_Call

+ func (_c *DependencyVulnRepository_Read_Call) RunAndReturn(run func(id string) (models.DependencyVuln, error)) *DependencyVulnRepository_Read_Call

+ type DependencyVulnRepository_SaveBatch_Call struct

+ func (_c *DependencyVulnRepository_SaveBatch_Call) Return(err error) *DependencyVulnRepository_SaveBatch_Call

+ func (_c *DependencyVulnRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.DependencyVuln)) *DependencyVulnRepository_SaveBatch_Call

+ func (_c *DependencyVulnRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.DependencyVuln) error) *DependencyVulnRepository_SaveBatch_Call

+ type DependencyVulnRepository_Save_Call struct

+ func (_c *DependencyVulnRepository_Save_Call) Return(err error) *DependencyVulnRepository_Save_Call

+ func (_c *DependencyVulnRepository_Save_Call) Run(run func(tx core.DB, t *models.DependencyVuln)) *DependencyVulnRepository_Save_Call

+ func (_c *DependencyVulnRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.DependencyVuln) error) *DependencyVulnRepository_Save_Call

+ type DependencyVulnRepository_Transaction_Call struct

+ func (_c *DependencyVulnRepository_Transaction_Call) Return(err error) *DependencyVulnRepository_Transaction_Call

+ func (_c *DependencyVulnRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *DependencyVulnRepository_Transaction_Call

+ func (_c *DependencyVulnRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *DependencyVulnRepository_Transaction_Call

+ type DependencyVulnRepository_Upsert_Call struct

+ func (_c *DependencyVulnRepository_Upsert_Call) Return(err error) *DependencyVulnRepository_Upsert_Call

+ func (_c *DependencyVulnRepository_Upsert_Call) Run(run func(t *[]*models.DependencyVuln, conflictingColumns []clause.Column, ...)) *DependencyVulnRepository_Upsert_Call

+ func (_c *DependencyVulnRepository_Upsert_Call) RunAndReturn(...) *DependencyVulnRepository_Upsert_Call

+ type DependencyVulnService struct

+ func NewDependencyVulnService(t interface{ ... }) *DependencyVulnService

+ func (_m *DependencyVulnService) EXPECT() *DependencyVulnService_Expecter

+ func (_mock *DependencyVulnService) RecalculateRawRiskAssessment(tx core.DB, responsible string, dependencyVulns []models.DependencyVuln, ...) error

+ func (_mock *DependencyVulnService) SyncAllIssues(org models.Org, project models.Project, asset models.Asset, ...) error

+ func (_mock *DependencyVulnService) SyncIssues(org models.Org, project models.Project, asset models.Asset, ...) error

+ func (_mock *DependencyVulnService) UpdateDependencyVulnState(tx core.DB, assetID uuid.UUID, userID string, ...) (models.VulnEvent, error)

+ func (_mock *DependencyVulnService) UserDetectedDependencyVulnInAnotherArtifact(tx core.DB, vulnerabilities []models.DependencyVuln, artifactName string) error

+ func (_mock *DependencyVulnService) UserDetectedDependencyVulns(tx core.DB, artifactName string, dependencyVulns []models.DependencyVuln, ...) error

+ func (_mock *DependencyVulnService) UserDetectedExistingVulnOnDifferentBranch(tx core.DB, artifactName string, dependencyVulns []models.DependencyVuln, ...) error

+ func (_mock *DependencyVulnService) UserDidNotDetectDependencyVulnInArtifactAnymore(tx core.DB, vulnerabilities []models.DependencyVuln, artifactName string) error

+ func (_mock *DependencyVulnService) UserFixedDependencyVulns(tx core.DB, userID string, dependencyVulns []models.DependencyVuln, ...) error

+ type DependencyVulnService_Expecter struct

+ func (_e *DependencyVulnService_Expecter) RecalculateRawRiskAssessment(tx interface{}, responsible interface{}, dependencyVulns interface{}, ...) *DependencyVulnService_RecalculateRawRiskAssessment_Call

+ func (_e *DependencyVulnService_Expecter) SyncAllIssues(org interface{}, project interface{}, asset interface{}, ...) *DependencyVulnService_SyncAllIssues_Call

+ func (_e *DependencyVulnService_Expecter) SyncIssues(org interface{}, project interface{}, asset interface{}, ...) *DependencyVulnService_SyncIssues_Call

+ func (_e *DependencyVulnService_Expecter) UpdateDependencyVulnState(tx interface{}, assetID interface{}, userID interface{}, ...) *DependencyVulnService_UpdateDependencyVulnState_Call

+ func (_e *DependencyVulnService_Expecter) UserDetectedDependencyVulnInAnotherArtifact(tx interface{}, vulnerabilities interface{}, artifactName interface{}) *DependencyVulnService_UserDetectedDependencyVulnInAnotherArtifact_Call

+ func (_e *DependencyVulnService_Expecter) UserDetectedDependencyVulns(tx interface{}, artifactName interface{}, dependencyVulns interface{}, ...) *DependencyVulnService_UserDetectedDependencyVulns_Call

+ func (_e *DependencyVulnService_Expecter) UserDetectedExistingVulnOnDifferentBranch(tx interface{}, artifactName interface{}, dependencyVulns interface{}, ...) *DependencyVulnService_UserDetectedExistingVulnOnDifferentBranch_Call

+ func (_e *DependencyVulnService_Expecter) UserDidNotDetectDependencyVulnInArtifactAnymore(tx interface{}, vulnerabilities interface{}, artifactName interface{}) *DependencyVulnService_UserDidNotDetectDependencyVulnInArtifactAnymore_Call

+ func (_e *DependencyVulnService_Expecter) UserFixedDependencyVulns(tx interface{}, userID interface{}, dependencyVulns interface{}, ...) *DependencyVulnService_UserFixedDependencyVulns_Call

+ type DependencyVulnService_RecalculateRawRiskAssessment_Call struct

+ func (_c *DependencyVulnService_RecalculateRawRiskAssessment_Call) Return(err error) *DependencyVulnService_RecalculateRawRiskAssessment_Call

+ func (_c *DependencyVulnService_RecalculateRawRiskAssessment_Call) Run(...) *DependencyVulnService_RecalculateRawRiskAssessment_Call

+ func (_c *DependencyVulnService_RecalculateRawRiskAssessment_Call) RunAndReturn(...) *DependencyVulnService_RecalculateRawRiskAssessment_Call

+ type DependencyVulnService_SyncAllIssues_Call struct

+ func (_c *DependencyVulnService_SyncAllIssues_Call) Return(err error) *DependencyVulnService_SyncAllIssues_Call

+ func (_c *DependencyVulnService_SyncAllIssues_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *DependencyVulnService_SyncAllIssues_Call

+ func (_c *DependencyVulnService_SyncAllIssues_Call) RunAndReturn(...) *DependencyVulnService_SyncAllIssues_Call

+ type DependencyVulnService_SyncIssues_Call struct

+ func (_c *DependencyVulnService_SyncIssues_Call) Return(err error) *DependencyVulnService_SyncIssues_Call

+ func (_c *DependencyVulnService_SyncIssues_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *DependencyVulnService_SyncIssues_Call

+ func (_c *DependencyVulnService_SyncIssues_Call) RunAndReturn(...) *DependencyVulnService_SyncIssues_Call

+ type DependencyVulnService_UpdateDependencyVulnState_Call struct

+ func (_c *DependencyVulnService_UpdateDependencyVulnState_Call) Return(vulnEvent models.VulnEvent, err error) *DependencyVulnService_UpdateDependencyVulnState_Call

+ func (_c *DependencyVulnService_UpdateDependencyVulnState_Call) Run(run func(tx core.DB, assetID uuid.UUID, userID string, ...)) *DependencyVulnService_UpdateDependencyVulnState_Call

+ func (_c *DependencyVulnService_UpdateDependencyVulnState_Call) RunAndReturn(...) *DependencyVulnService_UpdateDependencyVulnState_Call

+ type DependencyVulnService_UserDetectedDependencyVulnInAnotherArtifact_Call struct

+ func (_c *DependencyVulnService_UserDetectedDependencyVulnInAnotherArtifact_Call) Return(err error) *DependencyVulnService_UserDetectedDependencyVulnInAnotherArtifact_Call

+ func (_c *DependencyVulnService_UserDetectedDependencyVulnInAnotherArtifact_Call) Run(...) *DependencyVulnService_UserDetectedDependencyVulnInAnotherArtifact_Call

+ func (_c *DependencyVulnService_UserDetectedDependencyVulnInAnotherArtifact_Call) RunAndReturn(...) *DependencyVulnService_UserDetectedDependencyVulnInAnotherArtifact_Call

+ type DependencyVulnService_UserDetectedDependencyVulns_Call struct

+ func (_c *DependencyVulnService_UserDetectedDependencyVulns_Call) Return(err error) *DependencyVulnService_UserDetectedDependencyVulns_Call

+ func (_c *DependencyVulnService_UserDetectedDependencyVulns_Call) Run(...) *DependencyVulnService_UserDetectedDependencyVulns_Call

+ func (_c *DependencyVulnService_UserDetectedDependencyVulns_Call) RunAndReturn(...) *DependencyVulnService_UserDetectedDependencyVulns_Call

+ type DependencyVulnService_UserDetectedExistingVulnOnDifferentBranch_Call struct

+ func (_c *DependencyVulnService_UserDetectedExistingVulnOnDifferentBranch_Call) Return(err error) *DependencyVulnService_UserDetectedExistingVulnOnDifferentBranch_Call

+ func (_c *DependencyVulnService_UserDetectedExistingVulnOnDifferentBranch_Call) Run(...) *DependencyVulnService_UserDetectedExistingVulnOnDifferentBranch_Call

+ func (_c *DependencyVulnService_UserDetectedExistingVulnOnDifferentBranch_Call) RunAndReturn(...) *DependencyVulnService_UserDetectedExistingVulnOnDifferentBranch_Call

+ type DependencyVulnService_UserDidNotDetectDependencyVulnInArtifactAnymore_Call struct

+ func (_c *DependencyVulnService_UserDidNotDetectDependencyVulnInArtifactAnymore_Call) Return(err error) *DependencyVulnService_UserDidNotDetectDependencyVulnInArtifactAnymore_Call

+ func (_c *DependencyVulnService_UserDidNotDetectDependencyVulnInArtifactAnymore_Call) Run(...) *DependencyVulnService_UserDidNotDetectDependencyVulnInArtifactAnymore_Call

+ func (_c *DependencyVulnService_UserDidNotDetectDependencyVulnInArtifactAnymore_Call) RunAndReturn(...) *DependencyVulnService_UserDidNotDetectDependencyVulnInArtifactAnymore_Call

+ type DependencyVulnService_UserFixedDependencyVulns_Call struct

+ func (_c *DependencyVulnService_UserFixedDependencyVulns_Call) Return(err error) *DependencyVulnService_UserFixedDependencyVulns_Call

+ func (_c *DependencyVulnService_UserFixedDependencyVulns_Call) Run(...) *DependencyVulnService_UserFixedDependencyVulns_Call

+ func (_c *DependencyVulnService_UserFixedDependencyVulns_Call) RunAndReturn(...) *DependencyVulnService_UserFixedDependencyVulns_Call

+ type Diffable struct

+ func NewDiffable(t interface{ ... }) *Diffable

+ func (_m *Diffable) EXPECT() *Diffable_Expecter

+ func (_mock *Diffable) AssetVersionIndependentHash() string

+ func (_mock *Diffable) GetAssetVersionName() string

+ func (_mock *Diffable) GetEvents() []models.VulnEvent

+ type Diffable_AssetVersionIndependentHash_Call struct

+ func (_c *Diffable_AssetVersionIndependentHash_Call) Return(s string) *Diffable_AssetVersionIndependentHash_Call

+ func (_c *Diffable_AssetVersionIndependentHash_Call) Run(run func()) *Diffable_AssetVersionIndependentHash_Call

+ func (_c *Diffable_AssetVersionIndependentHash_Call) RunAndReturn(run func() string) *Diffable_AssetVersionIndependentHash_Call

+ type Diffable_Expecter struct

+ func (_e *Diffable_Expecter) AssetVersionIndependentHash() *Diffable_AssetVersionIndependentHash_Call

+ func (_e *Diffable_Expecter) GetAssetVersionName() *Diffable_GetAssetVersionName_Call

+ func (_e *Diffable_Expecter) GetEvents() *Diffable_GetEvents_Call

+ type Diffable_GetAssetVersionName_Call struct

+ func (_c *Diffable_GetAssetVersionName_Call) Return(s string) *Diffable_GetAssetVersionName_Call

+ func (_c *Diffable_GetAssetVersionName_Call) Run(run func()) *Diffable_GetAssetVersionName_Call

+ func (_c *Diffable_GetAssetVersionName_Call) RunAndReturn(run func() string) *Diffable_GetAssetVersionName_Call

+ type Diffable_GetEvents_Call struct

+ func (_c *Diffable_GetEvents_Call) Return(vulnEvents []models.VulnEvent) *Diffable_GetEvents_Call

+ func (_c *Diffable_GetEvents_Call) Run(run func()) *Diffable_GetEvents_Call

+ func (_c *Diffable_GetEvents_Call) RunAndReturn(run func() []models.VulnEvent) *Diffable_GetEvents_Call

+ type ExploitRepository struct

+ func NewExploitRepository(t interface{ ... }) *ExploitRepository

+ func (_m *ExploitRepository) EXPECT() *ExploitRepository_Expecter

+ func (_mock *ExploitRepository) GetAllExploitsID() ([]string, error)

+ func (_mock *ExploitRepository) SaveBatch(tx core.DB, exploits []models.Exploit) error

+ type ExploitRepository_Expecter struct

+ func (_e *ExploitRepository_Expecter) GetAllExploitsID() *ExploitRepository_GetAllExploitsID_Call

+ func (_e *ExploitRepository_Expecter) SaveBatch(tx interface{}, exploits interface{}) *ExploitRepository_SaveBatch_Call

+ type ExploitRepository_GetAllExploitsID_Call struct

+ func (_c *ExploitRepository_GetAllExploitsID_Call) Return(strings []string, err error) *ExploitRepository_GetAllExploitsID_Call

+ func (_c *ExploitRepository_GetAllExploitsID_Call) Run(run func()) *ExploitRepository_GetAllExploitsID_Call

+ func (_c *ExploitRepository_GetAllExploitsID_Call) RunAndReturn(run func() ([]string, error)) *ExploitRepository_GetAllExploitsID_Call

+ type ExploitRepository_SaveBatch_Call struct

+ func (_c *ExploitRepository_SaveBatch_Call) Return(err error) *ExploitRepository_SaveBatch_Call

+ func (_c *ExploitRepository_SaveBatch_Call) Run(run func(tx core.DB, exploits []models.Exploit)) *ExploitRepository_SaveBatch_Call

+ func (_c *ExploitRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, exploits []models.Exploit) error) *ExploitRepository_SaveBatch_Call

+ type ExternalEntityProviderService struct

+ func NewExternalEntityProviderService(t interface{ ... }) *ExternalEntityProviderService

+ func (_m *ExternalEntityProviderService) EXPECT() *ExternalEntityProviderService_Expecter

+ func (_mock *ExternalEntityProviderService) RefreshExternalEntityProviderProjects(ctx core.Context, org models.Org, user string) error

+ func (_mock *ExternalEntityProviderService) SyncOrgs(c core.Context) ([]*models.Org, error)

+ func (_mock *ExternalEntityProviderService) TriggerOrgSync(c core.Context) error

+ type ExternalEntityProviderService_Expecter struct

+ func (_e *ExternalEntityProviderService_Expecter) RefreshExternalEntityProviderProjects(ctx interface{}, org interface{}, user interface{}) *ExternalEntityProviderService_RefreshExternalEntityProviderProjects_Call

+ func (_e *ExternalEntityProviderService_Expecter) SyncOrgs(c interface{}) *ExternalEntityProviderService_SyncOrgs_Call

+ func (_e *ExternalEntityProviderService_Expecter) TriggerOrgSync(c interface{}) *ExternalEntityProviderService_TriggerOrgSync_Call

+ type ExternalEntityProviderService_RefreshExternalEntityProviderProjects_Call struct

+ func (_c *ExternalEntityProviderService_RefreshExternalEntityProviderProjects_Call) Return(err error) *ExternalEntityProviderService_RefreshExternalEntityProviderProjects_Call

+ func (_c *ExternalEntityProviderService_RefreshExternalEntityProviderProjects_Call) Run(run func(ctx core.Context, org models.Org, user string)) *ExternalEntityProviderService_RefreshExternalEntityProviderProjects_Call

+ func (_c *ExternalEntityProviderService_RefreshExternalEntityProviderProjects_Call) RunAndReturn(run func(ctx core.Context, org models.Org, user string) error) *ExternalEntityProviderService_RefreshExternalEntityProviderProjects_Call

+ type ExternalEntityProviderService_SyncOrgs_Call struct

+ func (_c *ExternalEntityProviderService_SyncOrgs_Call) Return(orgs []*models.Org, err error) *ExternalEntityProviderService_SyncOrgs_Call

+ func (_c *ExternalEntityProviderService_SyncOrgs_Call) Run(run func(c core.Context)) *ExternalEntityProviderService_SyncOrgs_Call

+ func (_c *ExternalEntityProviderService_SyncOrgs_Call) RunAndReturn(run func(c core.Context) ([]*models.Org, error)) *ExternalEntityProviderService_SyncOrgs_Call

+ type ExternalEntityProviderService_TriggerOrgSync_Call struct

+ func (_c *ExternalEntityProviderService_TriggerOrgSync_Call) Return(err error) *ExternalEntityProviderService_TriggerOrgSync_Call

+ func (_c *ExternalEntityProviderService_TriggerOrgSync_Call) Run(run func(c core.Context)) *ExternalEntityProviderService_TriggerOrgSync_Call

+ func (_c *ExternalEntityProviderService_TriggerOrgSync_Call) RunAndReturn(run func(c core.Context) error) *ExternalEntityProviderService_TriggerOrgSync_Call

+ type ExternalUserRepository struct

+ func NewExternalUserRepository(t interface{ ... }) *ExternalUserRepository

+ func (_m *ExternalUserRepository) EXPECT() *ExternalUserRepository_Expecter

+ func (_mock *ExternalUserRepository) FindByOrgID(tx core.DB, orgID uuid.UUID) ([]models.ExternalUser, error)

+ func (_mock *ExternalUserRepository) GetDB(tx core.DB) core.DB

+ func (_mock *ExternalUserRepository) Save(db core.DB, user *models.ExternalUser) error

+ type ExternalUserRepository_Expecter struct

+ func (_e *ExternalUserRepository_Expecter) FindByOrgID(tx interface{}, orgID interface{}) *ExternalUserRepository_FindByOrgID_Call

+ func (_e *ExternalUserRepository_Expecter) GetDB(tx interface{}) *ExternalUserRepository_GetDB_Call

+ func (_e *ExternalUserRepository_Expecter) Save(db interface{}, user interface{}) *ExternalUserRepository_Save_Call

+ type ExternalUserRepository_FindByOrgID_Call struct

+ func (_c *ExternalUserRepository_FindByOrgID_Call) Return(externalUsers []models.ExternalUser, err error) *ExternalUserRepository_FindByOrgID_Call

+ func (_c *ExternalUserRepository_FindByOrgID_Call) Run(run func(tx core.DB, orgID uuid.UUID)) *ExternalUserRepository_FindByOrgID_Call

+ func (_c *ExternalUserRepository_FindByOrgID_Call) RunAndReturn(run func(tx core.DB, orgID uuid.UUID) ([]models.ExternalUser, error)) *ExternalUserRepository_FindByOrgID_Call

+ type ExternalUserRepository_GetDB_Call struct

+ func (_c *ExternalUserRepository_GetDB_Call) Return(v core.DB) *ExternalUserRepository_GetDB_Call

+ func (_c *ExternalUserRepository_GetDB_Call) Run(run func(tx core.DB)) *ExternalUserRepository_GetDB_Call

+ func (_c *ExternalUserRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *ExternalUserRepository_GetDB_Call

+ type ExternalUserRepository_Save_Call struct

+ func (_c *ExternalUserRepository_Save_Call) Return(err error) *ExternalUserRepository_Save_Call

+ func (_c *ExternalUserRepository_Save_Call) Run(run func(db core.DB, user *models.ExternalUser)) *ExternalUserRepository_Save_Call

+ func (_c *ExternalUserRepository_Save_Call) RunAndReturn(run func(db core.DB, user *models.ExternalUser) error) *ExternalUserRepository_Save_Call

+ type FireAndForgetSynchronizer struct

+ func NewFireAndForgetSynchronizer(t interface{ ... }) *FireAndForgetSynchronizer

+ func (_m *FireAndForgetSynchronizer) EXPECT() *FireAndForgetSynchronizer_Expecter

+ func (_mock *FireAndForgetSynchronizer) FireAndForget(fn func())

+ type FireAndForgetSynchronizer_Expecter struct

+ func (_e *FireAndForgetSynchronizer_Expecter) FireAndForget(fn interface{}) *FireAndForgetSynchronizer_FireAndForget_Call

+ type FireAndForgetSynchronizer_FireAndForget_Call struct

+ func (_c *FireAndForgetSynchronizer_FireAndForget_Call) Return() *FireAndForgetSynchronizer_FireAndForget_Call

+ func (_c *FireAndForgetSynchronizer_FireAndForget_Call) Run(run func(fn func())) *FireAndForgetSynchronizer_FireAndForget_Call

+ func (_c *FireAndForgetSynchronizer_FireAndForget_Call) RunAndReturn(run func(fn func())) *FireAndForgetSynchronizer_FireAndForget_Call

+ type FirstPartyVulnRepository struct

+ func NewFirstPartyVulnRepository(t interface{ ... }) *FirstPartyVulnRepository

+ func (_m *FirstPartyVulnRepository) EXPECT() *FirstPartyVulnRepository_Expecter

+ func (_mock *FirstPartyVulnRepository) Activate(tx core.DB, id string) error

+ func (_mock *FirstPartyVulnRepository) All() ([]models.FirstPartyVuln, error)

+ func (_mock *FirstPartyVulnRepository) ApplyAndSave(tx core.DB, dependencyVuln *models.FirstPartyVuln, vulnEvent *models.VulnEvent) error

+ func (_mock *FirstPartyVulnRepository) Begin() core.DB

+ func (_mock *FirstPartyVulnRepository) Create(tx core.DB, t *models.FirstPartyVuln) error

+ func (_mock *FirstPartyVulnRepository) CreateBatch(tx core.DB, ts []models.FirstPartyVuln) error

+ func (_mock *FirstPartyVulnRepository) Delete(tx core.DB, id string) error

+ func (_mock *FirstPartyVulnRepository) DeleteBatch(tx core.DB, ids []models.FirstPartyVuln) error

+ func (_mock *FirstPartyVulnRepository) GetByAssetID(tx core.DB, assetID uuid.UUID) ([]models.FirstPartyVuln, error)

+ func (_mock *FirstPartyVulnRepository) GetByAssetVersion(tx core.DB, assetVersionName string, assetID uuid.UUID) ([]models.FirstPartyVuln, error)

+ func (_mock *FirstPartyVulnRepository) GetByAssetVersionPaged(tx core.DB, assetVersionName string, assetID uuid.UUID, pageInfo core.PageInfo, ...) (core.Paged[models.FirstPartyVuln], map[string]int, error)

+ func (_mock *FirstPartyVulnRepository) GetDB(tx core.DB) core.DB

+ func (_mock *FirstPartyVulnRepository) GetDefaultFirstPartyVulnsByOrgIDPaged(tx core.DB, userAllowedProjectIds []string, pageInfo core.PageInfo, ...) (core.Paged[models.FirstPartyVuln], error)

+ func (_mock *FirstPartyVulnRepository) GetDefaultFirstPartyVulnsByProjectIDPaged(tx core.DB, projectID uuid.UUID, pageInfo core.PageInfo, search string, ...) (core.Paged[models.FirstPartyVuln], error)

+ func (_mock *FirstPartyVulnRepository) GetFirstPartyVulnsByOtherAssetVersions(tx core.DB, assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.FirstPartyVuln, error)

+ func (_mock *FirstPartyVulnRepository) List(ids []string) ([]models.FirstPartyVuln, error)

+ func (_mock *FirstPartyVulnRepository) ListByScanner(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.FirstPartyVuln, error)

+ func (_mock *FirstPartyVulnRepository) Read(id string) (models.FirstPartyVuln, error)

+ func (_mock *FirstPartyVulnRepository) Save(tx core.DB, vuln *models.FirstPartyVuln) error

+ func (_mock *FirstPartyVulnRepository) SaveBatch(tx core.DB, vulns []models.FirstPartyVuln) error

+ func (_mock *FirstPartyVulnRepository) Transaction(txFunc func(core.DB) error) error

+ func (_mock *FirstPartyVulnRepository) Upsert(t *[]*models.FirstPartyVuln, conflictingColumns []clause.Column, ...) error

+ type FirstPartyVulnRepository_Activate_Call struct

+ func (_c *FirstPartyVulnRepository_Activate_Call) Return(err error) *FirstPartyVulnRepository_Activate_Call

+ func (_c *FirstPartyVulnRepository_Activate_Call) Run(run func(tx core.DB, id string)) *FirstPartyVulnRepository_Activate_Call

+ func (_c *FirstPartyVulnRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *FirstPartyVulnRepository_Activate_Call

+ type FirstPartyVulnRepository_All_Call struct

+ func (_c *FirstPartyVulnRepository_All_Call) Return(firstPartyVulns []models.FirstPartyVuln, err error) *FirstPartyVulnRepository_All_Call

+ func (_c *FirstPartyVulnRepository_All_Call) Run(run func()) *FirstPartyVulnRepository_All_Call

+ func (_c *FirstPartyVulnRepository_All_Call) RunAndReturn(run func() ([]models.FirstPartyVuln, error)) *FirstPartyVulnRepository_All_Call

+ type FirstPartyVulnRepository_ApplyAndSave_Call struct

+ func (_c *FirstPartyVulnRepository_ApplyAndSave_Call) Return(err error) *FirstPartyVulnRepository_ApplyAndSave_Call

+ func (_c *FirstPartyVulnRepository_ApplyAndSave_Call) Run(...) *FirstPartyVulnRepository_ApplyAndSave_Call

+ func (_c *FirstPartyVulnRepository_ApplyAndSave_Call) RunAndReturn(...) *FirstPartyVulnRepository_ApplyAndSave_Call

+ type FirstPartyVulnRepository_Begin_Call struct

+ func (_c *FirstPartyVulnRepository_Begin_Call) Return(v core.DB) *FirstPartyVulnRepository_Begin_Call

+ func (_c *FirstPartyVulnRepository_Begin_Call) Run(run func()) *FirstPartyVulnRepository_Begin_Call

+ func (_c *FirstPartyVulnRepository_Begin_Call) RunAndReturn(run func() core.DB) *FirstPartyVulnRepository_Begin_Call

+ type FirstPartyVulnRepository_CreateBatch_Call struct

+ func (_c *FirstPartyVulnRepository_CreateBatch_Call) Return(err error) *FirstPartyVulnRepository_CreateBatch_Call

+ func (_c *FirstPartyVulnRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.FirstPartyVuln)) *FirstPartyVulnRepository_CreateBatch_Call

+ func (_c *FirstPartyVulnRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.FirstPartyVuln) error) *FirstPartyVulnRepository_CreateBatch_Call

+ type FirstPartyVulnRepository_Create_Call struct

+ func (_c *FirstPartyVulnRepository_Create_Call) Return(err error) *FirstPartyVulnRepository_Create_Call

+ func (_c *FirstPartyVulnRepository_Create_Call) Run(run func(tx core.DB, t *models.FirstPartyVuln)) *FirstPartyVulnRepository_Create_Call

+ func (_c *FirstPartyVulnRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.FirstPartyVuln) error) *FirstPartyVulnRepository_Create_Call

+ type FirstPartyVulnRepository_DeleteBatch_Call struct

+ func (_c *FirstPartyVulnRepository_DeleteBatch_Call) Return(err error) *FirstPartyVulnRepository_DeleteBatch_Call

+ func (_c *FirstPartyVulnRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.FirstPartyVuln)) *FirstPartyVulnRepository_DeleteBatch_Call

+ func (_c *FirstPartyVulnRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.FirstPartyVuln) error) *FirstPartyVulnRepository_DeleteBatch_Call

+ type FirstPartyVulnRepository_Delete_Call struct

+ func (_c *FirstPartyVulnRepository_Delete_Call) Return(err error) *FirstPartyVulnRepository_Delete_Call

+ func (_c *FirstPartyVulnRepository_Delete_Call) Run(run func(tx core.DB, id string)) *FirstPartyVulnRepository_Delete_Call

+ func (_c *FirstPartyVulnRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *FirstPartyVulnRepository_Delete_Call

+ type FirstPartyVulnRepository_Expecter struct

+ func (_e *FirstPartyVulnRepository_Expecter) Activate(tx interface{}, id interface{}) *FirstPartyVulnRepository_Activate_Call

+ func (_e *FirstPartyVulnRepository_Expecter) All() *FirstPartyVulnRepository_All_Call

+ func (_e *FirstPartyVulnRepository_Expecter) ApplyAndSave(tx interface{}, dependencyVuln interface{}, vulnEvent interface{}) *FirstPartyVulnRepository_ApplyAndSave_Call

+ func (_e *FirstPartyVulnRepository_Expecter) Begin() *FirstPartyVulnRepository_Begin_Call

+ func (_e *FirstPartyVulnRepository_Expecter) Create(tx interface{}, t interface{}) *FirstPartyVulnRepository_Create_Call

+ func (_e *FirstPartyVulnRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *FirstPartyVulnRepository_CreateBatch_Call

+ func (_e *FirstPartyVulnRepository_Expecter) Delete(tx interface{}, id interface{}) *FirstPartyVulnRepository_Delete_Call

+ func (_e *FirstPartyVulnRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *FirstPartyVulnRepository_DeleteBatch_Call

+ func (_e *FirstPartyVulnRepository_Expecter) GetByAssetID(tx interface{}, assetID interface{}) *FirstPartyVulnRepository_GetByAssetID_Call

+ func (_e *FirstPartyVulnRepository_Expecter) GetByAssetVersion(tx interface{}, assetVersionName interface{}, assetID interface{}) *FirstPartyVulnRepository_GetByAssetVersion_Call

+ func (_e *FirstPartyVulnRepository_Expecter) GetByAssetVersionPaged(tx interface{}, assetVersionName interface{}, assetID interface{}, ...) *FirstPartyVulnRepository_GetByAssetVersionPaged_Call

+ func (_e *FirstPartyVulnRepository_Expecter) GetDB(tx interface{}) *FirstPartyVulnRepository_GetDB_Call

+ func (_e *FirstPartyVulnRepository_Expecter) GetDefaultFirstPartyVulnsByOrgIDPaged(tx interface{}, userAllowedProjectIds interface{}, pageInfo interface{}, ...) *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByOrgIDPaged_Call

+ func (_e *FirstPartyVulnRepository_Expecter) GetDefaultFirstPartyVulnsByProjectIDPaged(tx interface{}, projectID interface{}, pageInfo interface{}, ...) *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByProjectIDPaged_Call

+ func (_e *FirstPartyVulnRepository_Expecter) GetFirstPartyVulnsByOtherAssetVersions(tx interface{}, assetVersionName interface{}, assetID interface{}, ...) *FirstPartyVulnRepository_GetFirstPartyVulnsByOtherAssetVersions_Call

+ func (_e *FirstPartyVulnRepository_Expecter) List(ids interface{}) *FirstPartyVulnRepository_List_Call

+ func (_e *FirstPartyVulnRepository_Expecter) ListByScanner(assetVersionName interface{}, assetID interface{}, scannerID interface{}) *FirstPartyVulnRepository_ListByScanner_Call

+ func (_e *FirstPartyVulnRepository_Expecter) Read(id interface{}) *FirstPartyVulnRepository_Read_Call

+ func (_e *FirstPartyVulnRepository_Expecter) Save(tx interface{}, vuln interface{}) *FirstPartyVulnRepository_Save_Call

+ func (_e *FirstPartyVulnRepository_Expecter) SaveBatch(tx interface{}, vulns interface{}) *FirstPartyVulnRepository_SaveBatch_Call

+ func (_e *FirstPartyVulnRepository_Expecter) Transaction(txFunc interface{}) *FirstPartyVulnRepository_Transaction_Call

+ func (_e *FirstPartyVulnRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *FirstPartyVulnRepository_Upsert_Call

+ type FirstPartyVulnRepository_GetByAssetID_Call struct

+ func (_c *FirstPartyVulnRepository_GetByAssetID_Call) Return(firstPartyVulns []models.FirstPartyVuln, err error) *FirstPartyVulnRepository_GetByAssetID_Call

+ func (_c *FirstPartyVulnRepository_GetByAssetID_Call) Run(run func(tx core.DB, assetID uuid.UUID)) *FirstPartyVulnRepository_GetByAssetID_Call

+ func (_c *FirstPartyVulnRepository_GetByAssetID_Call) RunAndReturn(run func(tx core.DB, assetID uuid.UUID) ([]models.FirstPartyVuln, error)) *FirstPartyVulnRepository_GetByAssetID_Call

+ type FirstPartyVulnRepository_GetByAssetVersionPaged_Call struct

+ func (_c *FirstPartyVulnRepository_GetByAssetVersionPaged_Call) Return(paged core.Paged[models.FirstPartyVuln], stringToInt map[string]int, err error) *FirstPartyVulnRepository_GetByAssetVersionPaged_Call

+ func (_c *FirstPartyVulnRepository_GetByAssetVersionPaged_Call) Run(...) *FirstPartyVulnRepository_GetByAssetVersionPaged_Call

+ func (_c *FirstPartyVulnRepository_GetByAssetVersionPaged_Call) RunAndReturn(...) *FirstPartyVulnRepository_GetByAssetVersionPaged_Call

+ type FirstPartyVulnRepository_GetByAssetVersion_Call struct

+ func (_c *FirstPartyVulnRepository_GetByAssetVersion_Call) Return(firstPartyVulns []models.FirstPartyVuln, err error) *FirstPartyVulnRepository_GetByAssetVersion_Call

+ func (_c *FirstPartyVulnRepository_GetByAssetVersion_Call) Run(run func(tx core.DB, assetVersionName string, assetID uuid.UUID)) *FirstPartyVulnRepository_GetByAssetVersion_Call

+ func (_c *FirstPartyVulnRepository_GetByAssetVersion_Call) RunAndReturn(...) *FirstPartyVulnRepository_GetByAssetVersion_Call

+ type FirstPartyVulnRepository_GetDB_Call struct

+ func (_c *FirstPartyVulnRepository_GetDB_Call) Return(v core.DB) *FirstPartyVulnRepository_GetDB_Call

+ func (_c *FirstPartyVulnRepository_GetDB_Call) Run(run func(tx core.DB)) *FirstPartyVulnRepository_GetDB_Call

+ func (_c *FirstPartyVulnRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *FirstPartyVulnRepository_GetDB_Call

+ type FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByOrgIDPaged_Call struct

+ func (_c *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByOrgIDPaged_Call) Return(paged core.Paged[models.FirstPartyVuln], err error) *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByOrgIDPaged_Call

+ func (_c *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByOrgIDPaged_Call) Run(...) *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByOrgIDPaged_Call

+ func (_c *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByOrgIDPaged_Call) RunAndReturn(...) *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByOrgIDPaged_Call

+ type FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByProjectIDPaged_Call struct

+ func (_c *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByProjectIDPaged_Call) Return(paged core.Paged[models.FirstPartyVuln], err error) *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByProjectIDPaged_Call

+ func (_c *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByProjectIDPaged_Call) Run(...) *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByProjectIDPaged_Call

+ func (_c *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByProjectIDPaged_Call) RunAndReturn(...) *FirstPartyVulnRepository_GetDefaultFirstPartyVulnsByProjectIDPaged_Call

+ type FirstPartyVulnRepository_GetFirstPartyVulnsByOtherAssetVersions_Call struct

+ func (_c *FirstPartyVulnRepository_GetFirstPartyVulnsByOtherAssetVersions_Call) Return(firstPartyVulns []models.FirstPartyVuln, err error) *FirstPartyVulnRepository_GetFirstPartyVulnsByOtherAssetVersions_Call

+ func (_c *FirstPartyVulnRepository_GetFirstPartyVulnsByOtherAssetVersions_Call) Run(...) *FirstPartyVulnRepository_GetFirstPartyVulnsByOtherAssetVersions_Call

+ func (_c *FirstPartyVulnRepository_GetFirstPartyVulnsByOtherAssetVersions_Call) RunAndReturn(...) *FirstPartyVulnRepository_GetFirstPartyVulnsByOtherAssetVersions_Call

+ type FirstPartyVulnRepository_ListByScanner_Call struct

+ func (_c *FirstPartyVulnRepository_ListByScanner_Call) Return(firstPartyVulns []models.FirstPartyVuln, err error) *FirstPartyVulnRepository_ListByScanner_Call

+ func (_c *FirstPartyVulnRepository_ListByScanner_Call) Run(run func(assetVersionName string, assetID uuid.UUID, scannerID string)) *FirstPartyVulnRepository_ListByScanner_Call

+ func (_c *FirstPartyVulnRepository_ListByScanner_Call) RunAndReturn(...) *FirstPartyVulnRepository_ListByScanner_Call

+ type FirstPartyVulnRepository_List_Call struct

+ func (_c *FirstPartyVulnRepository_List_Call) Return(firstPartyVulns []models.FirstPartyVuln, err error) *FirstPartyVulnRepository_List_Call

+ func (_c *FirstPartyVulnRepository_List_Call) Run(run func(ids []string)) *FirstPartyVulnRepository_List_Call

+ func (_c *FirstPartyVulnRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.FirstPartyVuln, error)) *FirstPartyVulnRepository_List_Call

+ type FirstPartyVulnRepository_Read_Call struct

+ func (_c *FirstPartyVulnRepository_Read_Call) Return(firstPartyVuln models.FirstPartyVuln, err error) *FirstPartyVulnRepository_Read_Call

+ func (_c *FirstPartyVulnRepository_Read_Call) Run(run func(id string)) *FirstPartyVulnRepository_Read_Call

+ func (_c *FirstPartyVulnRepository_Read_Call) RunAndReturn(run func(id string) (models.FirstPartyVuln, error)) *FirstPartyVulnRepository_Read_Call

+ type FirstPartyVulnRepository_SaveBatch_Call struct

+ func (_c *FirstPartyVulnRepository_SaveBatch_Call) Return(err error) *FirstPartyVulnRepository_SaveBatch_Call

+ func (_c *FirstPartyVulnRepository_SaveBatch_Call) Run(run func(tx core.DB, vulns []models.FirstPartyVuln)) *FirstPartyVulnRepository_SaveBatch_Call

+ func (_c *FirstPartyVulnRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, vulns []models.FirstPartyVuln) error) *FirstPartyVulnRepository_SaveBatch_Call

+ type FirstPartyVulnRepository_Save_Call struct

+ func (_c *FirstPartyVulnRepository_Save_Call) Return(err error) *FirstPartyVulnRepository_Save_Call

+ func (_c *FirstPartyVulnRepository_Save_Call) Run(run func(tx core.DB, vuln *models.FirstPartyVuln)) *FirstPartyVulnRepository_Save_Call

+ func (_c *FirstPartyVulnRepository_Save_Call) RunAndReturn(run func(tx core.DB, vuln *models.FirstPartyVuln) error) *FirstPartyVulnRepository_Save_Call

+ type FirstPartyVulnRepository_Transaction_Call struct

+ func (_c *FirstPartyVulnRepository_Transaction_Call) Return(err error) *FirstPartyVulnRepository_Transaction_Call

+ func (_c *FirstPartyVulnRepository_Transaction_Call) Run(run func(txFunc func(core.DB) error)) *FirstPartyVulnRepository_Transaction_Call

+ func (_c *FirstPartyVulnRepository_Transaction_Call) RunAndReturn(run func(txFunc func(core.DB) error) error) *FirstPartyVulnRepository_Transaction_Call

+ type FirstPartyVulnRepository_Upsert_Call struct

+ func (_c *FirstPartyVulnRepository_Upsert_Call) Return(err error) *FirstPartyVulnRepository_Upsert_Call

+ func (_c *FirstPartyVulnRepository_Upsert_Call) Run(run func(t *[]*models.FirstPartyVuln, conflictingColumns []clause.Column, ...)) *FirstPartyVulnRepository_Upsert_Call

+ func (_c *FirstPartyVulnRepository_Upsert_Call) RunAndReturn(...) *FirstPartyVulnRepository_Upsert_Call

+ type FirstPartyVulnService struct

+ func NewFirstPartyVulnService(t interface{ ... }) *FirstPartyVulnService

+ func (_m *FirstPartyVulnService) EXPECT() *FirstPartyVulnService_Expecter

+ func (_mock *FirstPartyVulnService) SyncAllIssues(org models.Org, project models.Project, asset models.Asset, ...) error

+ func (_mock *FirstPartyVulnService) SyncIssues(org models.Org, project models.Project, asset models.Asset, ...) error

+ func (_mock *FirstPartyVulnService) UpdateFirstPartyVulnState(tx core.DB, userID string, firstPartyVuln *models.FirstPartyVuln, ...) (models.VulnEvent, error)

+ func (_mock *FirstPartyVulnService) UserDetectedExistingFirstPartyVulnOnDifferentBranch(tx core.DB, scannerID string, firstPartyVulns []models.FirstPartyVuln, ...) error

+ func (_mock *FirstPartyVulnService) UserDetectedFirstPartyVulns(tx core.DB, userID string, scannerID string, ...) error

+ func (_mock *FirstPartyVulnService) UserFixedFirstPartyVulns(tx core.DB, userID string, firstPartyVulns []models.FirstPartyVuln) error

+ type FirstPartyVulnService_Expecter struct

+ func (_e *FirstPartyVulnService_Expecter) SyncAllIssues(org interface{}, project interface{}, asset interface{}, ...) *FirstPartyVulnService_SyncAllIssues_Call

+ func (_e *FirstPartyVulnService_Expecter) SyncIssues(org interface{}, project interface{}, asset interface{}, ...) *FirstPartyVulnService_SyncIssues_Call

+ func (_e *FirstPartyVulnService_Expecter) UpdateFirstPartyVulnState(tx interface{}, userID interface{}, firstPartyVuln interface{}, ...) *FirstPartyVulnService_UpdateFirstPartyVulnState_Call

+ func (_e *FirstPartyVulnService_Expecter) UserDetectedExistingFirstPartyVulnOnDifferentBranch(tx interface{}, scannerID interface{}, firstPartyVulns interface{}, ...) ...

+ func (_e *FirstPartyVulnService_Expecter) UserDetectedFirstPartyVulns(tx interface{}, userID interface{}, scannerID interface{}, ...) *FirstPartyVulnService_UserDetectedFirstPartyVulns_Call

+ func (_e *FirstPartyVulnService_Expecter) UserFixedFirstPartyVulns(tx interface{}, userID interface{}, firstPartyVulns interface{}) *FirstPartyVulnService_UserFixedFirstPartyVulns_Call

+ type FirstPartyVulnService_SyncAllIssues_Call struct

+ func (_c *FirstPartyVulnService_SyncAllIssues_Call) Return(err error) *FirstPartyVulnService_SyncAllIssues_Call

+ func (_c *FirstPartyVulnService_SyncAllIssues_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *FirstPartyVulnService_SyncAllIssues_Call

+ func (_c *FirstPartyVulnService_SyncAllIssues_Call) RunAndReturn(...) *FirstPartyVulnService_SyncAllIssues_Call

+ type FirstPartyVulnService_SyncIssues_Call struct

+ func (_c *FirstPartyVulnService_SyncIssues_Call) Return(err error) *FirstPartyVulnService_SyncIssues_Call

+ func (_c *FirstPartyVulnService_SyncIssues_Call) Run(run func(org models.Org, project models.Project, asset models.Asset, ...)) *FirstPartyVulnService_SyncIssues_Call

+ func (_c *FirstPartyVulnService_SyncIssues_Call) RunAndReturn(...) *FirstPartyVulnService_SyncIssues_Call

+ type FirstPartyVulnService_UpdateFirstPartyVulnState_Call struct

+ func (_c *FirstPartyVulnService_UpdateFirstPartyVulnState_Call) Return(vulnEvent models.VulnEvent, err error) *FirstPartyVulnService_UpdateFirstPartyVulnState_Call

+ func (_c *FirstPartyVulnService_UpdateFirstPartyVulnState_Call) Run(...) *FirstPartyVulnService_UpdateFirstPartyVulnState_Call

+ func (_c *FirstPartyVulnService_UpdateFirstPartyVulnState_Call) RunAndReturn(...) *FirstPartyVulnService_UpdateFirstPartyVulnState_Call

+ type FirstPartyVulnService_UserDetectedExistingFirstPartyVulnOnDifferentBranch_Call struct

+ func (_c *FirstPartyVulnService_UserDetectedExistingFirstPartyVulnOnDifferentBranch_Call) Return(err error) ...

+ func (_c *FirstPartyVulnService_UserDetectedExistingFirstPartyVulnOnDifferentBranch_Call) Run(...) ...

+ func (_c *FirstPartyVulnService_UserDetectedExistingFirstPartyVulnOnDifferentBranch_Call) RunAndReturn(...) ...

+ type FirstPartyVulnService_UserDetectedFirstPartyVulns_Call struct

+ func (_c *FirstPartyVulnService_UserDetectedFirstPartyVulns_Call) Return(err error) *FirstPartyVulnService_UserDetectedFirstPartyVulns_Call

+ func (_c *FirstPartyVulnService_UserDetectedFirstPartyVulns_Call) Run(run func(tx core.DB, userID string, scannerID string, ...)) *FirstPartyVulnService_UserDetectedFirstPartyVulns_Call

+ func (_c *FirstPartyVulnService_UserDetectedFirstPartyVulns_Call) RunAndReturn(run func(tx core.DB, userID string, scannerID string, ...) error) *FirstPartyVulnService_UserDetectedFirstPartyVulns_Call

+ type FirstPartyVulnService_UserFixedFirstPartyVulns_Call struct

+ func (_c *FirstPartyVulnService_UserFixedFirstPartyVulns_Call) Return(err error) *FirstPartyVulnService_UserFixedFirstPartyVulns_Call

+ func (_c *FirstPartyVulnService_UserFixedFirstPartyVulns_Call) Run(run func(tx core.DB, userID string, firstPartyVulns []models.FirstPartyVuln)) *FirstPartyVulnService_UserFixedFirstPartyVulns_Call

+ func (_c *FirstPartyVulnService_UserFixedFirstPartyVulns_Call) RunAndReturn(...) *FirstPartyVulnService_UserFixedFirstPartyVulns_Call

+ type GitLabOauth2TokenRepository struct

+ func NewGitLabOauth2TokenRepository(t interface{ ... }) *GitLabOauth2TokenRepository

+ func (_m *GitLabOauth2TokenRepository) EXPECT() *GitLabOauth2TokenRepository_Expecter

+ func (_mock *GitLabOauth2TokenRepository) CreateIfNotExists(tokens []*models.GitLabOauth2Token) error

+ func (_mock *GitLabOauth2TokenRepository) Delete(tx core.DB, tokens []models.GitLabOauth2Token) error

+ func (_mock *GitLabOauth2TokenRepository) DeleteByUserIDAndProviderID(userID string, providerID string) error

+ func (_mock *GitLabOauth2TokenRepository) FindByUserID(userID string) ([]models.GitLabOauth2Token, error)

+ func (_mock *GitLabOauth2TokenRepository) FindByUserIDAndProviderID(userID string, providerID string) (*models.GitLabOauth2Token, error)

+ func (_mock *GitLabOauth2TokenRepository) Save(tx core.DB, model ...*models.GitLabOauth2Token) error

+ type GitLabOauth2TokenRepository_CreateIfNotExists_Call struct

+ func (_c *GitLabOauth2TokenRepository_CreateIfNotExists_Call) Return(err error) *GitLabOauth2TokenRepository_CreateIfNotExists_Call

+ func (_c *GitLabOauth2TokenRepository_CreateIfNotExists_Call) Run(run func(tokens []*models.GitLabOauth2Token)) *GitLabOauth2TokenRepository_CreateIfNotExists_Call

+ func (_c *GitLabOauth2TokenRepository_CreateIfNotExists_Call) RunAndReturn(run func(tokens []*models.GitLabOauth2Token) error) *GitLabOauth2TokenRepository_CreateIfNotExists_Call

+ type GitLabOauth2TokenRepository_DeleteByUserIDAndProviderID_Call struct

+ func (_c *GitLabOauth2TokenRepository_DeleteByUserIDAndProviderID_Call) Return(err error) *GitLabOauth2TokenRepository_DeleteByUserIDAndProviderID_Call

+ func (_c *GitLabOauth2TokenRepository_DeleteByUserIDAndProviderID_Call) Run(run func(userID string, providerID string)) *GitLabOauth2TokenRepository_DeleteByUserIDAndProviderID_Call

+ func (_c *GitLabOauth2TokenRepository_DeleteByUserIDAndProviderID_Call) RunAndReturn(run func(userID string, providerID string) error) *GitLabOauth2TokenRepository_DeleteByUserIDAndProviderID_Call

+ type GitLabOauth2TokenRepository_Delete_Call struct

+ func (_c *GitLabOauth2TokenRepository_Delete_Call) Return(err error) *GitLabOauth2TokenRepository_Delete_Call

+ func (_c *GitLabOauth2TokenRepository_Delete_Call) Run(run func(tx core.DB, tokens []models.GitLabOauth2Token)) *GitLabOauth2TokenRepository_Delete_Call

+ func (_c *GitLabOauth2TokenRepository_Delete_Call) RunAndReturn(run func(tx core.DB, tokens []models.GitLabOauth2Token) error) *GitLabOauth2TokenRepository_Delete_Call

+ type GitLabOauth2TokenRepository_Expecter struct

+ func (_e *GitLabOauth2TokenRepository_Expecter) CreateIfNotExists(tokens interface{}) *GitLabOauth2TokenRepository_CreateIfNotExists_Call

+ func (_e *GitLabOauth2TokenRepository_Expecter) Delete(tx interface{}, tokens interface{}) *GitLabOauth2TokenRepository_Delete_Call

+ func (_e *GitLabOauth2TokenRepository_Expecter) DeleteByUserIDAndProviderID(userID interface{}, providerID interface{}) *GitLabOauth2TokenRepository_DeleteByUserIDAndProviderID_Call

+ func (_e *GitLabOauth2TokenRepository_Expecter) FindByUserID(userID interface{}) *GitLabOauth2TokenRepository_FindByUserID_Call

+ func (_e *GitLabOauth2TokenRepository_Expecter) FindByUserIDAndProviderID(userID interface{}, providerID interface{}) *GitLabOauth2TokenRepository_FindByUserIDAndProviderID_Call

+ func (_e *GitLabOauth2TokenRepository_Expecter) Save(tx interface{}, model ...interface{}) *GitLabOauth2TokenRepository_Save_Call

+ type GitLabOauth2TokenRepository_FindByUserIDAndProviderID_Call struct

+ func (_c *GitLabOauth2TokenRepository_FindByUserIDAndProviderID_Call) Return(gitLabOauth2Token *models.GitLabOauth2Token, err error) *GitLabOauth2TokenRepository_FindByUserIDAndProviderID_Call

+ func (_c *GitLabOauth2TokenRepository_FindByUserIDAndProviderID_Call) Run(run func(userID string, providerID string)) *GitLabOauth2TokenRepository_FindByUserIDAndProviderID_Call

+ func (_c *GitLabOauth2TokenRepository_FindByUserIDAndProviderID_Call) RunAndReturn(run func(userID string, providerID string) (*models.GitLabOauth2Token, error)) *GitLabOauth2TokenRepository_FindByUserIDAndProviderID_Call

+ type GitLabOauth2TokenRepository_FindByUserID_Call struct

+ func (_c *GitLabOauth2TokenRepository_FindByUserID_Call) Return(gitLabOauth2Tokens []models.GitLabOauth2Token, err error) *GitLabOauth2TokenRepository_FindByUserID_Call

+ func (_c *GitLabOauth2TokenRepository_FindByUserID_Call) Run(run func(userID string)) *GitLabOauth2TokenRepository_FindByUserID_Call

+ func (_c *GitLabOauth2TokenRepository_FindByUserID_Call) RunAndReturn(run func(userID string) ([]models.GitLabOauth2Token, error)) *GitLabOauth2TokenRepository_FindByUserID_Call

+ type GitLabOauth2TokenRepository_Save_Call struct

+ func (_c *GitLabOauth2TokenRepository_Save_Call) Return(err error) *GitLabOauth2TokenRepository_Save_Call

+ func (_c *GitLabOauth2TokenRepository_Save_Call) Run(run func(tx core.DB, model ...*models.GitLabOauth2Token)) *GitLabOauth2TokenRepository_Save_Call

+ func (_c *GitLabOauth2TokenRepository_Save_Call) RunAndReturn(run func(tx core.DB, model ...*models.GitLabOauth2Token) error) *GitLabOauth2TokenRepository_Save_Call

+ type GitLister struct

+ func NewGitLister(t interface{ ... }) *GitLister

+ func (_m *GitLister) EXPECT() *GitLister_Expecter

+ func (_mock *GitLister) GetBranchName(path string) (string, error)

+ func (_mock *GitLister) GetDefaultBranchName(path string) (string, error)

+ func (_mock *GitLister) GetTags(path string) ([]string, error)

+ func (_mock *GitLister) GitCommitCount(path string, tag *string) (int, error)

+ func (_mock *GitLister) MarkAllPathsAsSafe() error

+ type GitLister_Expecter struct

+ func (_e *GitLister_Expecter) GetBranchName(path interface{}) *GitLister_GetBranchName_Call

+ func (_e *GitLister_Expecter) GetDefaultBranchName(path interface{}) *GitLister_GetDefaultBranchName_Call

+ func (_e *GitLister_Expecter) GetTags(path interface{}) *GitLister_GetTags_Call

+ func (_e *GitLister_Expecter) GitCommitCount(path interface{}, tag interface{}) *GitLister_GitCommitCount_Call

+ func (_e *GitLister_Expecter) MarkAllPathsAsSafe() *GitLister_MarkAllPathsAsSafe_Call

+ type GitLister_GetBranchName_Call struct

+ func (_c *GitLister_GetBranchName_Call) Return(s string, err error) *GitLister_GetBranchName_Call

+ func (_c *GitLister_GetBranchName_Call) Run(run func(path string)) *GitLister_GetBranchName_Call

+ func (_c *GitLister_GetBranchName_Call) RunAndReturn(run func(path string) (string, error)) *GitLister_GetBranchName_Call

+ type GitLister_GetDefaultBranchName_Call struct

+ func (_c *GitLister_GetDefaultBranchName_Call) Return(s string, err error) *GitLister_GetDefaultBranchName_Call

+ func (_c *GitLister_GetDefaultBranchName_Call) Run(run func(path string)) *GitLister_GetDefaultBranchName_Call

+ func (_c *GitLister_GetDefaultBranchName_Call) RunAndReturn(run func(path string) (string, error)) *GitLister_GetDefaultBranchName_Call

+ type GitLister_GetTags_Call struct

+ func (_c *GitLister_GetTags_Call) Return(strings []string, err error) *GitLister_GetTags_Call

+ func (_c *GitLister_GetTags_Call) Run(run func(path string)) *GitLister_GetTags_Call

+ func (_c *GitLister_GetTags_Call) RunAndReturn(run func(path string) ([]string, error)) *GitLister_GetTags_Call

+ type GitLister_GitCommitCount_Call struct

+ func (_c *GitLister_GitCommitCount_Call) Return(n int, err error) *GitLister_GitCommitCount_Call

+ func (_c *GitLister_GitCommitCount_Call) Run(run func(path string, tag *string)) *GitLister_GitCommitCount_Call

+ func (_c *GitLister_GitCommitCount_Call) RunAndReturn(run func(path string, tag *string) (int, error)) *GitLister_GitCommitCount_Call

+ type GitLister_MarkAllPathsAsSafe_Call struct

+ func (_c *GitLister_MarkAllPathsAsSafe_Call) Return(err error) *GitLister_MarkAllPathsAsSafe_Call

+ func (_c *GitLister_MarkAllPathsAsSafe_Call) Run(run func()) *GitLister_MarkAllPathsAsSafe_Call

+ func (_c *GitLister_MarkAllPathsAsSafe_Call) RunAndReturn(run func() error) *GitLister_MarkAllPathsAsSafe_Call

+ type GithubAppInstallationRepository struct

+ func NewGithubAppInstallationRepository(t interface{ ... }) *GithubAppInstallationRepository

+ func (_m *GithubAppInstallationRepository) EXPECT() *GithubAppInstallationRepository_Expecter

+ func (_mock *GithubAppInstallationRepository) Delete(tx core.DB, installationID int) error

+ func (_mock *GithubAppInstallationRepository) FindByOrganizationID(orgID uuid.UUID) ([]models.GithubAppInstallation, error)

+ func (_mock *GithubAppInstallationRepository) Read(installationID int) (models.GithubAppInstallation, error)

+ func (_mock *GithubAppInstallationRepository) Save(tx core.DB, model *models.GithubAppInstallation) error

+ type GithubAppInstallationRepository_Delete_Call struct

+ func (_c *GithubAppInstallationRepository_Delete_Call) Return(err error) *GithubAppInstallationRepository_Delete_Call

+ func (_c *GithubAppInstallationRepository_Delete_Call) Run(run func(tx core.DB, installationID int)) *GithubAppInstallationRepository_Delete_Call

+ func (_c *GithubAppInstallationRepository_Delete_Call) RunAndReturn(run func(tx core.DB, installationID int) error) *GithubAppInstallationRepository_Delete_Call

+ type GithubAppInstallationRepository_Expecter struct

+ func (_e *GithubAppInstallationRepository_Expecter) Delete(tx interface{}, installationID interface{}) *GithubAppInstallationRepository_Delete_Call

+ func (_e *GithubAppInstallationRepository_Expecter) FindByOrganizationID(orgID interface{}) *GithubAppInstallationRepository_FindByOrganizationID_Call

+ func (_e *GithubAppInstallationRepository_Expecter) Read(installationID interface{}) *GithubAppInstallationRepository_Read_Call

+ func (_e *GithubAppInstallationRepository_Expecter) Save(tx interface{}, model interface{}) *GithubAppInstallationRepository_Save_Call

+ type GithubAppInstallationRepository_FindByOrganizationID_Call struct

+ func (_c *GithubAppInstallationRepository_FindByOrganizationID_Call) Return(githubAppInstallations []models.GithubAppInstallation, err error) *GithubAppInstallationRepository_FindByOrganizationID_Call

+ func (_c *GithubAppInstallationRepository_FindByOrganizationID_Call) Run(run func(orgID uuid.UUID)) *GithubAppInstallationRepository_FindByOrganizationID_Call

+ func (_c *GithubAppInstallationRepository_FindByOrganizationID_Call) RunAndReturn(run func(orgID uuid.UUID) ([]models.GithubAppInstallation, error)) *GithubAppInstallationRepository_FindByOrganizationID_Call

+ type GithubAppInstallationRepository_Read_Call struct

+ func (_c *GithubAppInstallationRepository_Read_Call) Return(githubAppInstallation models.GithubAppInstallation, err error) *GithubAppInstallationRepository_Read_Call

+ func (_c *GithubAppInstallationRepository_Read_Call) Run(run func(installationID int)) *GithubAppInstallationRepository_Read_Call

+ func (_c *GithubAppInstallationRepository_Read_Call) RunAndReturn(run func(installationID int) (models.GithubAppInstallation, error)) *GithubAppInstallationRepository_Read_Call

+ type GithubAppInstallationRepository_Save_Call struct

+ func (_c *GithubAppInstallationRepository_Save_Call) Return(err error) *GithubAppInstallationRepository_Save_Call

+ func (_c *GithubAppInstallationRepository_Save_Call) Run(run func(tx core.DB, model *models.GithubAppInstallation)) *GithubAppInstallationRepository_Save_Call

+ func (_c *GithubAppInstallationRepository_Save_Call) RunAndReturn(run func(tx core.DB, model *models.GithubAppInstallation) error) *GithubAppInstallationRepository_Save_Call

+ type GithubClientFacade struct

+ func NewGithubClientFacade(t interface{ ... }) *GithubClientFacade

+ func (_m *GithubClientFacade) EXPECT() *GithubClientFacade_Expecter

+ func (_mock *GithubClientFacade) CreateIssue(ctx context.Context, owner string, repo string, issue *github.IssueRequest) (*github.Issue, *github.Response, error)

+ func (_mock *GithubClientFacade) CreateIssueComment(ctx context.Context, owner string, repo string, number int, ...) (*github.IssueComment, *github.Response, error)

+ func (_mock *GithubClientFacade) EditIssue(ctx context.Context, owner string, repo string, number int, ...) (*github.Issue, *github.Response, error)

+ func (_mock *GithubClientFacade) EditIssueLabel(ctx context.Context, owner string, repo string, name string, ...) (*github.Label, *github.Response, error)

+ func (_mock *GithubClientFacade) IsCollaboratorInRepository(ctx context.Context, owner string, repoID string, userID int64, ...) (bool, error)

+ type GithubClientFacade_CreateIssueComment_Call struct

+ func (_c *GithubClientFacade_CreateIssueComment_Call) Return(issueComment *github.IssueComment, response *github.Response, err error) *GithubClientFacade_CreateIssueComment_Call

+ func (_c *GithubClientFacade_CreateIssueComment_Call) Run(run func(ctx context.Context, owner string, repo string, number int, ...)) *GithubClientFacade_CreateIssueComment_Call

+ func (_c *GithubClientFacade_CreateIssueComment_Call) RunAndReturn(...) *GithubClientFacade_CreateIssueComment_Call

+ type GithubClientFacade_CreateIssue_Call struct

+ func (_c *GithubClientFacade_CreateIssue_Call) Return(issue1 *github.Issue, response *github.Response, err error) *GithubClientFacade_CreateIssue_Call

+ func (_c *GithubClientFacade_CreateIssue_Call) Run(...) *GithubClientFacade_CreateIssue_Call

+ func (_c *GithubClientFacade_CreateIssue_Call) RunAndReturn(...) *GithubClientFacade_CreateIssue_Call

+ type GithubClientFacade_EditIssueLabel_Call struct

+ func (_c *GithubClientFacade_EditIssueLabel_Call) Return(label1 *github.Label, response *github.Response, err error) *GithubClientFacade_EditIssueLabel_Call

+ func (_c *GithubClientFacade_EditIssueLabel_Call) Run(run func(ctx context.Context, owner string, repo string, name string, ...)) *GithubClientFacade_EditIssueLabel_Call

+ func (_c *GithubClientFacade_EditIssueLabel_Call) RunAndReturn(...) *GithubClientFacade_EditIssueLabel_Call

+ type GithubClientFacade_EditIssue_Call struct

+ func (_c *GithubClientFacade_EditIssue_Call) Return(issue1 *github.Issue, response *github.Response, err error) *GithubClientFacade_EditIssue_Call

+ func (_c *GithubClientFacade_EditIssue_Call) Run(run func(ctx context.Context, owner string, repo string, number int, ...)) *GithubClientFacade_EditIssue_Call

+ func (_c *GithubClientFacade_EditIssue_Call) RunAndReturn(...) *GithubClientFacade_EditIssue_Call

+ type GithubClientFacade_Expecter struct

+ func (_e *GithubClientFacade_Expecter) CreateIssue(ctx interface{}, owner interface{}, repo interface{}, issue interface{}) *GithubClientFacade_CreateIssue_Call

+ func (_e *GithubClientFacade_Expecter) CreateIssueComment(ctx interface{}, owner interface{}, repo interface{}, number interface{}, ...) *GithubClientFacade_CreateIssueComment_Call

+ func (_e *GithubClientFacade_Expecter) EditIssue(ctx interface{}, owner interface{}, repo interface{}, number interface{}, ...) *GithubClientFacade_EditIssue_Call

+ func (_e *GithubClientFacade_Expecter) EditIssueLabel(ctx interface{}, owner interface{}, repo interface{}, name interface{}, ...) *GithubClientFacade_EditIssueLabel_Call

+ func (_e *GithubClientFacade_Expecter) IsCollaboratorInRepository(ctx interface{}, owner interface{}, repoID interface{}, userID interface{}, ...) *GithubClientFacade_IsCollaboratorInRepository_Call

+ type GithubClientFacade_IsCollaboratorInRepository_Call struct

+ func (_c *GithubClientFacade_IsCollaboratorInRepository_Call) Return(b bool, err error) *GithubClientFacade_IsCollaboratorInRepository_Call

+ func (_c *GithubClientFacade_IsCollaboratorInRepository_Call) Run(run func(ctx context.Context, owner string, repoID string, userID int64, ...)) *GithubClientFacade_IsCollaboratorInRepository_Call

+ func (_c *GithubClientFacade_IsCollaboratorInRepository_Call) RunAndReturn(...) *GithubClientFacade_IsCollaboratorInRepository_Call

+ type GitlabClientFacade struct

+ func NewGitlabClientFacade(t interface{ ... }) *GitlabClientFacade

+ func (_m *GitlabClientFacade) EXPECT() *GitlabClientFacade_Expecter

+ func (_mock *GitlabClientFacade) AddProjectHook(ctx context.Context, projectID int, opt *gitlab.AddProjectHookOptions) (*gitlab.ProjectHook, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) CreateIssue(ctx context.Context, pid int, opt *gitlab.CreateIssueOptions) (*gitlab.Issue, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) CreateIssueComment(ctx context.Context, pid int, issue int, opt *gitlab.CreateIssueNoteOptions) (*gitlab.Note, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) CreateMergeRequest(ctx context.Context, project string, opt *gitlab.CreateMergeRequestOptions) (*gitlab.MergeRequest, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) CreateVariable(ctx context.Context, projectID int, opt *gitlab.CreateProjectVariableOptions) (*gitlab.ProjectVariable, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) DeleteProjectHook(ctx context.Context, projectID int, hookID int) (*gitlab.Response, error)

+ func (_mock *GitlabClientFacade) EditIssue(ctx context.Context, pid int, issue int, opt *gitlab.UpdateIssueOptions) (*gitlab.Issue, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) EditIssueLabel(ctx context.Context, pid int, issue int, labels []*gitlab.CreateLabelOptions) (*gitlab.Response, error)

+ func (_mock *GitlabClientFacade) FetchGroupAvatarBase64(groupID int) (string, error)

+ func (_mock *GitlabClientFacade) FetchProjectAvatarBase64(projectID int) (string, error)

+ func (_mock *GitlabClientFacade) GetClientID() string

+ func (_mock *GitlabClientFacade) GetGroup(ctx context.Context, groupID int) (*gitlab.Group, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) GetMemberInGroup(ctx context.Context, userID int, groupID int) (*gitlab.GroupMember, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) GetMemberInProject(ctx context.Context, userID int, projectID int) (*gitlab.ProjectMember, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) GetProject(ctx context.Context, projectID int) (*gitlab.Project, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) GetVersion(ctx context.Context) (*gitlab.Version, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) InviteReporter(ctx context.Context, projectID int, userID int) (*gitlab.ProjectMember, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) IsProjectMember(ctx context.Context, projectID int, userID int, ...) (bool, error)

+ func (_mock *GitlabClientFacade) ListGroups(ctx context.Context, opt *gitlab.ListGroupsOptions) ([]*gitlab.Group, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) ListProjectHooks(ctx context.Context, projectID int, options *gitlab.ListProjectHooksOptions) ([]*gitlab.ProjectHook, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) ListProjects(ctx context.Context, opt *gitlab.ListProjectsOptions) ([]*gitlab.Project, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) ListProjectsInGroup(ctx context.Context, groupID int, opt *gitlab.ListGroupProjectsOptions) ([]*gitlab.Project, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) ListVariables(ctx context.Context, projectID int, ...) ([]*gitlab.ProjectVariable, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) RemoveVariable(ctx context.Context, projectID int, key string) (*gitlab.Response, error)

+ func (_mock *GitlabClientFacade) UpdateVariable(ctx context.Context, projectID int, key string, ...) (*gitlab.ProjectVariable, *gitlab.Response, error)

+ func (_mock *GitlabClientFacade) Whoami(ctx context.Context) (*gitlab.User, *gitlab.Response, error)

+ type GitlabClientFacade_AddProjectHook_Call struct

+ func (_c *GitlabClientFacade_AddProjectHook_Call) Return(projectHook *gitlab.ProjectHook, response *gitlab.Response, err error) *GitlabClientFacade_AddProjectHook_Call

+ func (_c *GitlabClientFacade_AddProjectHook_Call) Run(...) *GitlabClientFacade_AddProjectHook_Call

+ func (_c *GitlabClientFacade_AddProjectHook_Call) RunAndReturn(...) *GitlabClientFacade_AddProjectHook_Call

+ type GitlabClientFacade_CreateIssueComment_Call struct

+ func (_c *GitlabClientFacade_CreateIssueComment_Call) Return(note *gitlab.Note, response *gitlab.Response, err error) *GitlabClientFacade_CreateIssueComment_Call

+ func (_c *GitlabClientFacade_CreateIssueComment_Call) Run(...) *GitlabClientFacade_CreateIssueComment_Call

+ func (_c *GitlabClientFacade_CreateIssueComment_Call) RunAndReturn(...) *GitlabClientFacade_CreateIssueComment_Call

+ type GitlabClientFacade_CreateIssue_Call struct

+ func (_c *GitlabClientFacade_CreateIssue_Call) Return(issue *gitlab.Issue, response *gitlab.Response, err error) *GitlabClientFacade_CreateIssue_Call

+ func (_c *GitlabClientFacade_CreateIssue_Call) Run(run func(ctx context.Context, pid int, opt *gitlab.CreateIssueOptions)) *GitlabClientFacade_CreateIssue_Call

+ func (_c *GitlabClientFacade_CreateIssue_Call) RunAndReturn(...) *GitlabClientFacade_CreateIssue_Call

+ type GitlabClientFacade_CreateMergeRequest_Call struct

+ func (_c *GitlabClientFacade_CreateMergeRequest_Call) Return(mergeRequest *gitlab.MergeRequest, response *gitlab.Response, err error) *GitlabClientFacade_CreateMergeRequest_Call

+ func (_c *GitlabClientFacade_CreateMergeRequest_Call) Run(...) *GitlabClientFacade_CreateMergeRequest_Call

+ func (_c *GitlabClientFacade_CreateMergeRequest_Call) RunAndReturn(...) *GitlabClientFacade_CreateMergeRequest_Call

+ type GitlabClientFacade_CreateVariable_Call struct

+ func (_c *GitlabClientFacade_CreateVariable_Call) Return(projectVariable *gitlab.ProjectVariable, response *gitlab.Response, err error) *GitlabClientFacade_CreateVariable_Call

+ func (_c *GitlabClientFacade_CreateVariable_Call) Run(...) *GitlabClientFacade_CreateVariable_Call

+ func (_c *GitlabClientFacade_CreateVariable_Call) RunAndReturn(...) *GitlabClientFacade_CreateVariable_Call

+ type GitlabClientFacade_DeleteProjectHook_Call struct

+ func (_c *GitlabClientFacade_DeleteProjectHook_Call) Return(response *gitlab.Response, err error) *GitlabClientFacade_DeleteProjectHook_Call

+ func (_c *GitlabClientFacade_DeleteProjectHook_Call) Run(run func(ctx context.Context, projectID int, hookID int)) *GitlabClientFacade_DeleteProjectHook_Call

+ func (_c *GitlabClientFacade_DeleteProjectHook_Call) RunAndReturn(...) *GitlabClientFacade_DeleteProjectHook_Call

+ type GitlabClientFacade_EditIssueLabel_Call struct

+ func (_c *GitlabClientFacade_EditIssueLabel_Call) Return(response *gitlab.Response, err error) *GitlabClientFacade_EditIssueLabel_Call

+ func (_c *GitlabClientFacade_EditIssueLabel_Call) Run(...) *GitlabClientFacade_EditIssueLabel_Call

+ func (_c *GitlabClientFacade_EditIssueLabel_Call) RunAndReturn(...) *GitlabClientFacade_EditIssueLabel_Call

+ type GitlabClientFacade_EditIssue_Call struct

+ func (_c *GitlabClientFacade_EditIssue_Call) Return(issue1 *gitlab.Issue, response *gitlab.Response, err error) *GitlabClientFacade_EditIssue_Call

+ func (_c *GitlabClientFacade_EditIssue_Call) Run(...) *GitlabClientFacade_EditIssue_Call

+ func (_c *GitlabClientFacade_EditIssue_Call) RunAndReturn(...) *GitlabClientFacade_EditIssue_Call

+ type GitlabClientFacade_Expecter struct

+ func (_e *GitlabClientFacade_Expecter) AddProjectHook(ctx interface{}, projectID interface{}, opt interface{}) *GitlabClientFacade_AddProjectHook_Call

+ func (_e *GitlabClientFacade_Expecter) CreateIssue(ctx interface{}, pid interface{}, opt interface{}) *GitlabClientFacade_CreateIssue_Call

+ func (_e *GitlabClientFacade_Expecter) CreateIssueComment(ctx interface{}, pid interface{}, issue interface{}, opt interface{}) *GitlabClientFacade_CreateIssueComment_Call

+ func (_e *GitlabClientFacade_Expecter) CreateMergeRequest(ctx interface{}, project interface{}, opt interface{}) *GitlabClientFacade_CreateMergeRequest_Call

+ func (_e *GitlabClientFacade_Expecter) CreateVariable(ctx interface{}, projectID interface{}, opt interface{}) *GitlabClientFacade_CreateVariable_Call

+ func (_e *GitlabClientFacade_Expecter) DeleteProjectHook(ctx interface{}, projectID interface{}, hookID interface{}) *GitlabClientFacade_DeleteProjectHook_Call

+ func (_e *GitlabClientFacade_Expecter) EditIssue(ctx interface{}, pid interface{}, issue interface{}, opt interface{}) *GitlabClientFacade_EditIssue_Call

+ func (_e *GitlabClientFacade_Expecter) EditIssueLabel(ctx interface{}, pid interface{}, issue interface{}, labels interface{}) *GitlabClientFacade_EditIssueLabel_Call

+ func (_e *GitlabClientFacade_Expecter) FetchGroupAvatarBase64(groupID interface{}) *GitlabClientFacade_FetchGroupAvatarBase64_Call

+ func (_e *GitlabClientFacade_Expecter) FetchProjectAvatarBase64(projectID interface{}) *GitlabClientFacade_FetchProjectAvatarBase64_Call

+ func (_e *GitlabClientFacade_Expecter) GetClientID() *GitlabClientFacade_GetClientID_Call

+ func (_e *GitlabClientFacade_Expecter) GetGroup(ctx interface{}, groupID interface{}) *GitlabClientFacade_GetGroup_Call

+ func (_e *GitlabClientFacade_Expecter) GetMemberInGroup(ctx interface{}, userID interface{}, groupID interface{}) *GitlabClientFacade_GetMemberInGroup_Call

+ func (_e *GitlabClientFacade_Expecter) GetMemberInProject(ctx interface{}, userID interface{}, projectID interface{}) *GitlabClientFacade_GetMemberInProject_Call

+ func (_e *GitlabClientFacade_Expecter) GetProject(ctx interface{}, projectID interface{}) *GitlabClientFacade_GetProject_Call

+ func (_e *GitlabClientFacade_Expecter) GetVersion(ctx interface{}) *GitlabClientFacade_GetVersion_Call

+ func (_e *GitlabClientFacade_Expecter) InviteReporter(ctx interface{}, projectID interface{}, userID interface{}) *GitlabClientFacade_InviteReporter_Call

+ func (_e *GitlabClientFacade_Expecter) IsProjectMember(ctx interface{}, projectID interface{}, userID interface{}, ...) *GitlabClientFacade_IsProjectMember_Call

+ func (_e *GitlabClientFacade_Expecter) ListGroups(ctx interface{}, opt interface{}) *GitlabClientFacade_ListGroups_Call

+ func (_e *GitlabClientFacade_Expecter) ListProjectHooks(ctx interface{}, projectID interface{}, options interface{}) *GitlabClientFacade_ListProjectHooks_Call

+ func (_e *GitlabClientFacade_Expecter) ListProjects(ctx interface{}, opt interface{}) *GitlabClientFacade_ListProjects_Call

+ func (_e *GitlabClientFacade_Expecter) ListProjectsInGroup(ctx interface{}, groupID interface{}, opt interface{}) *GitlabClientFacade_ListProjectsInGroup_Call

+ func (_e *GitlabClientFacade_Expecter) ListVariables(ctx interface{}, projectID interface{}, options interface{}) *GitlabClientFacade_ListVariables_Call

+ func (_e *GitlabClientFacade_Expecter) RemoveVariable(ctx interface{}, projectID interface{}, key interface{}) *GitlabClientFacade_RemoveVariable_Call

+ func (_e *GitlabClientFacade_Expecter) UpdateVariable(ctx interface{}, projectID interface{}, key interface{}, opt interface{}) *GitlabClientFacade_UpdateVariable_Call

+ func (_e *GitlabClientFacade_Expecter) Whoami(ctx interface{}) *GitlabClientFacade_Whoami_Call

+ type GitlabClientFacade_FetchGroupAvatarBase64_Call struct

+ func (_c *GitlabClientFacade_FetchGroupAvatarBase64_Call) Return(s string, err error) *GitlabClientFacade_FetchGroupAvatarBase64_Call

+ func (_c *GitlabClientFacade_FetchGroupAvatarBase64_Call) Run(run func(groupID int)) *GitlabClientFacade_FetchGroupAvatarBase64_Call

+ func (_c *GitlabClientFacade_FetchGroupAvatarBase64_Call) RunAndReturn(run func(groupID int) (string, error)) *GitlabClientFacade_FetchGroupAvatarBase64_Call

+ type GitlabClientFacade_FetchProjectAvatarBase64_Call struct

+ func (_c *GitlabClientFacade_FetchProjectAvatarBase64_Call) Return(s string, err error) *GitlabClientFacade_FetchProjectAvatarBase64_Call

+ func (_c *GitlabClientFacade_FetchProjectAvatarBase64_Call) Run(run func(projectID int)) *GitlabClientFacade_FetchProjectAvatarBase64_Call

+ func (_c *GitlabClientFacade_FetchProjectAvatarBase64_Call) RunAndReturn(run func(projectID int) (string, error)) *GitlabClientFacade_FetchProjectAvatarBase64_Call

+ type GitlabClientFacade_GetClientID_Call struct

+ func (_c *GitlabClientFacade_GetClientID_Call) Return(s string) *GitlabClientFacade_GetClientID_Call

+ func (_c *GitlabClientFacade_GetClientID_Call) Run(run func()) *GitlabClientFacade_GetClientID_Call

+ func (_c *GitlabClientFacade_GetClientID_Call) RunAndReturn(run func() string) *GitlabClientFacade_GetClientID_Call

+ type GitlabClientFacade_GetGroup_Call struct

+ func (_c *GitlabClientFacade_GetGroup_Call) Return(group *gitlab.Group, response *gitlab.Response, err error) *GitlabClientFacade_GetGroup_Call

+ func (_c *GitlabClientFacade_GetGroup_Call) Run(run func(ctx context.Context, groupID int)) *GitlabClientFacade_GetGroup_Call

+ func (_c *GitlabClientFacade_GetGroup_Call) RunAndReturn(...) *GitlabClientFacade_GetGroup_Call

+ type GitlabClientFacade_GetMemberInGroup_Call struct

+ func (_c *GitlabClientFacade_GetMemberInGroup_Call) Return(groupMember *gitlab.GroupMember, response *gitlab.Response, err error) *GitlabClientFacade_GetMemberInGroup_Call

+ func (_c *GitlabClientFacade_GetMemberInGroup_Call) Run(run func(ctx context.Context, userID int, groupID int)) *GitlabClientFacade_GetMemberInGroup_Call

+ func (_c *GitlabClientFacade_GetMemberInGroup_Call) RunAndReturn(...) *GitlabClientFacade_GetMemberInGroup_Call

+ type GitlabClientFacade_GetMemberInProject_Call struct

+ func (_c *GitlabClientFacade_GetMemberInProject_Call) Return(projectMember *gitlab.ProjectMember, response *gitlab.Response, err error) *GitlabClientFacade_GetMemberInProject_Call

+ func (_c *GitlabClientFacade_GetMemberInProject_Call) Run(run func(ctx context.Context, userID int, projectID int)) *GitlabClientFacade_GetMemberInProject_Call

+ func (_c *GitlabClientFacade_GetMemberInProject_Call) RunAndReturn(...) *GitlabClientFacade_GetMemberInProject_Call

+ type GitlabClientFacade_GetProject_Call struct

+ func (_c *GitlabClientFacade_GetProject_Call) Return(project *gitlab.Project, response *gitlab.Response, err error) *GitlabClientFacade_GetProject_Call

+ func (_c *GitlabClientFacade_GetProject_Call) Run(run func(ctx context.Context, projectID int)) *GitlabClientFacade_GetProject_Call

+ func (_c *GitlabClientFacade_GetProject_Call) RunAndReturn(...) *GitlabClientFacade_GetProject_Call

+ type GitlabClientFacade_GetVersion_Call struct

+ func (_c *GitlabClientFacade_GetVersion_Call) Return(version *gitlab.Version, response *gitlab.Response, err error) *GitlabClientFacade_GetVersion_Call

+ func (_c *GitlabClientFacade_GetVersion_Call) Run(run func(ctx context.Context)) *GitlabClientFacade_GetVersion_Call

+ func (_c *GitlabClientFacade_GetVersion_Call) RunAndReturn(run func(ctx context.Context) (*gitlab.Version, *gitlab.Response, error)) *GitlabClientFacade_GetVersion_Call

+ type GitlabClientFacade_InviteReporter_Call struct

+ func (_c *GitlabClientFacade_InviteReporter_Call) Return(projectMember *gitlab.ProjectMember, response *gitlab.Response, err error) *GitlabClientFacade_InviteReporter_Call

+ func (_c *GitlabClientFacade_InviteReporter_Call) Run(run func(ctx context.Context, projectID int, userID int)) *GitlabClientFacade_InviteReporter_Call

+ func (_c *GitlabClientFacade_InviteReporter_Call) RunAndReturn(...) *GitlabClientFacade_InviteReporter_Call

+ type GitlabClientFacade_IsProjectMember_Call struct

+ func (_c *GitlabClientFacade_IsProjectMember_Call) Return(b bool, err error) *GitlabClientFacade_IsProjectMember_Call

+ func (_c *GitlabClientFacade_IsProjectMember_Call) Run(run func(ctx context.Context, projectID int, userID int, ...)) *GitlabClientFacade_IsProjectMember_Call

+ func (_c *GitlabClientFacade_IsProjectMember_Call) RunAndReturn(run func(ctx context.Context, projectID int, userID int, ...) (bool, error)) *GitlabClientFacade_IsProjectMember_Call

+ type GitlabClientFacade_ListGroups_Call struct

+ func (_c *GitlabClientFacade_ListGroups_Call) Return(groups []*gitlab.Group, response *gitlab.Response, err error) *GitlabClientFacade_ListGroups_Call

+ func (_c *GitlabClientFacade_ListGroups_Call) Run(run func(ctx context.Context, opt *gitlab.ListGroupsOptions)) *GitlabClientFacade_ListGroups_Call

+ func (_c *GitlabClientFacade_ListGroups_Call) RunAndReturn(...) *GitlabClientFacade_ListGroups_Call

+ type GitlabClientFacade_ListProjectHooks_Call struct

+ func (_c *GitlabClientFacade_ListProjectHooks_Call) Return(projectHooks []*gitlab.ProjectHook, response *gitlab.Response, err error) *GitlabClientFacade_ListProjectHooks_Call

+ func (_c *GitlabClientFacade_ListProjectHooks_Call) Run(...) *GitlabClientFacade_ListProjectHooks_Call

+ func (_c *GitlabClientFacade_ListProjectHooks_Call) RunAndReturn(...) *GitlabClientFacade_ListProjectHooks_Call

+ type GitlabClientFacade_ListProjectsInGroup_Call struct

+ func (_c *GitlabClientFacade_ListProjectsInGroup_Call) Return(projects []*gitlab.Project, response *gitlab.Response, err error) *GitlabClientFacade_ListProjectsInGroup_Call

+ func (_c *GitlabClientFacade_ListProjectsInGroup_Call) Run(...) *GitlabClientFacade_ListProjectsInGroup_Call

+ func (_c *GitlabClientFacade_ListProjectsInGroup_Call) RunAndReturn(...) *GitlabClientFacade_ListProjectsInGroup_Call

+ type GitlabClientFacade_ListProjects_Call struct

+ func (_c *GitlabClientFacade_ListProjects_Call) Return(projects []*gitlab.Project, response *gitlab.Response, err error) *GitlabClientFacade_ListProjects_Call

+ func (_c *GitlabClientFacade_ListProjects_Call) Run(run func(ctx context.Context, opt *gitlab.ListProjectsOptions)) *GitlabClientFacade_ListProjects_Call

+ func (_c *GitlabClientFacade_ListProjects_Call) RunAndReturn(...) *GitlabClientFacade_ListProjects_Call

+ type GitlabClientFacade_ListVariables_Call struct

+ func (_c *GitlabClientFacade_ListVariables_Call) Return(projectVariables []*gitlab.ProjectVariable, response *gitlab.Response, ...) *GitlabClientFacade_ListVariables_Call

+ func (_c *GitlabClientFacade_ListVariables_Call) Run(run func(ctx context.Context, projectID int, ...)) *GitlabClientFacade_ListVariables_Call

+ func (_c *GitlabClientFacade_ListVariables_Call) RunAndReturn(...) *GitlabClientFacade_ListVariables_Call

+ type GitlabClientFacade_RemoveVariable_Call struct

+ func (_c *GitlabClientFacade_RemoveVariable_Call) Return(response *gitlab.Response, err error) *GitlabClientFacade_RemoveVariable_Call

+ func (_c *GitlabClientFacade_RemoveVariable_Call) Run(run func(ctx context.Context, projectID int, key string)) *GitlabClientFacade_RemoveVariable_Call

+ func (_c *GitlabClientFacade_RemoveVariable_Call) RunAndReturn(...) *GitlabClientFacade_RemoveVariable_Call

+ type GitlabClientFacade_UpdateVariable_Call struct

+ func (_c *GitlabClientFacade_UpdateVariable_Call) Return(projectVariable *gitlab.ProjectVariable, response *gitlab.Response, err error) *GitlabClientFacade_UpdateVariable_Call

+ func (_c *GitlabClientFacade_UpdateVariable_Call) Run(run func(ctx context.Context, projectID int, key string, ...)) *GitlabClientFacade_UpdateVariable_Call

+ func (_c *GitlabClientFacade_UpdateVariable_Call) RunAndReturn(...) *GitlabClientFacade_UpdateVariable_Call

+ type GitlabClientFacade_Whoami_Call struct

+ func (_c *GitlabClientFacade_Whoami_Call) Return(user *gitlab.User, response *gitlab.Response, err error) *GitlabClientFacade_Whoami_Call

+ func (_c *GitlabClientFacade_Whoami_Call) Run(run func(ctx context.Context)) *GitlabClientFacade_Whoami_Call

+ func (_c *GitlabClientFacade_Whoami_Call) RunAndReturn(run func(ctx context.Context) (*gitlab.User, *gitlab.Response, error)) *GitlabClientFacade_Whoami_Call

+ type GitlabClientFactory struct

+ func NewGitlabClientFactory(t interface{ ... }) *GitlabClientFactory

+ func (_m *GitlabClientFactory) EXPECT() *GitlabClientFactory_Expecter

+ func (_mock *GitlabClientFactory) FromAccessToken(accessToken string, baseURL string) (core.GitlabClientFacade, error)

+ func (_mock *GitlabClientFactory) FromIntegration(integration models.GitLabIntegration) (core.GitlabClientFacade, error)

+ func (_mock *GitlabClientFactory) FromIntegrationUUID(id uuid.UUID) (core.GitlabClientFacade, error)

+ func (_mock *GitlabClientFactory) FromOauth2Token(token models.GitLabOauth2Token, enableClientCache bool) (core.GitlabClientFacade, error)

+ type GitlabClientFactory_Expecter struct

+ func (_e *GitlabClientFactory_Expecter) FromAccessToken(accessToken interface{}, baseURL interface{}) *GitlabClientFactory_FromAccessToken_Call

+ func (_e *GitlabClientFactory_Expecter) FromIntegration(integration interface{}) *GitlabClientFactory_FromIntegration_Call

+ func (_e *GitlabClientFactory_Expecter) FromIntegrationUUID(id interface{}) *GitlabClientFactory_FromIntegrationUUID_Call

+ func (_e *GitlabClientFactory_Expecter) FromOauth2Token(token interface{}, enableClientCache interface{}) *GitlabClientFactory_FromOauth2Token_Call

+ type GitlabClientFactory_FromAccessToken_Call struct

+ func (_c *GitlabClientFactory_FromAccessToken_Call) Return(gitlabClientFacade core.GitlabClientFacade, err error) *GitlabClientFactory_FromAccessToken_Call

+ func (_c *GitlabClientFactory_FromAccessToken_Call) Run(run func(accessToken string, baseURL string)) *GitlabClientFactory_FromAccessToken_Call

+ func (_c *GitlabClientFactory_FromAccessToken_Call) RunAndReturn(run func(accessToken string, baseURL string) (core.GitlabClientFacade, error)) *GitlabClientFactory_FromAccessToken_Call

+ type GitlabClientFactory_FromIntegrationUUID_Call struct

+ func (_c *GitlabClientFactory_FromIntegrationUUID_Call) Return(gitlabClientFacade core.GitlabClientFacade, err error) *GitlabClientFactory_FromIntegrationUUID_Call

+ func (_c *GitlabClientFactory_FromIntegrationUUID_Call) Run(run func(id uuid.UUID)) *GitlabClientFactory_FromIntegrationUUID_Call

+ func (_c *GitlabClientFactory_FromIntegrationUUID_Call) RunAndReturn(run func(id uuid.UUID) (core.GitlabClientFacade, error)) *GitlabClientFactory_FromIntegrationUUID_Call

+ type GitlabClientFactory_FromIntegration_Call struct

+ func (_c *GitlabClientFactory_FromIntegration_Call) Return(gitlabClientFacade core.GitlabClientFacade, err error) *GitlabClientFactory_FromIntegration_Call

+ func (_c *GitlabClientFactory_FromIntegration_Call) Run(run func(integration models.GitLabIntegration)) *GitlabClientFactory_FromIntegration_Call

+ func (_c *GitlabClientFactory_FromIntegration_Call) RunAndReturn(...) *GitlabClientFactory_FromIntegration_Call

+ type GitlabClientFactory_FromOauth2Token_Call struct

+ func (_c *GitlabClientFactory_FromOauth2Token_Call) Return(gitlabClientFacade core.GitlabClientFacade, err error) *GitlabClientFactory_FromOauth2Token_Call

+ func (_c *GitlabClientFactory_FromOauth2Token_Call) Run(run func(token models.GitLabOauth2Token, enableClientCache bool)) *GitlabClientFactory_FromOauth2Token_Call

+ func (_c *GitlabClientFactory_FromOauth2Token_Call) RunAndReturn(...) *GitlabClientFactory_FromOauth2Token_Call

+ type GitlabIntegrationRepository struct

+ func NewGitlabIntegrationRepository(t interface{ ... }) *GitlabIntegrationRepository

+ func (_m *GitlabIntegrationRepository) EXPECT() *GitlabIntegrationRepository_Expecter

+ func (_mock *GitlabIntegrationRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *GitlabIntegrationRepository) FindByOrganizationID(orgID uuid.UUID) ([]models.GitLabIntegration, error)

+ func (_mock *GitlabIntegrationRepository) Read(id uuid.UUID) (models.GitLabIntegration, error)

+ func (_mock *GitlabIntegrationRepository) Save(tx core.DB, model *models.GitLabIntegration) error

+ type GitlabIntegrationRepository_Delete_Call struct

+ func (_c *GitlabIntegrationRepository_Delete_Call) Return(err error) *GitlabIntegrationRepository_Delete_Call

+ func (_c *GitlabIntegrationRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *GitlabIntegrationRepository_Delete_Call

+ func (_c *GitlabIntegrationRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *GitlabIntegrationRepository_Delete_Call

+ type GitlabIntegrationRepository_Expecter struct

+ func (_e *GitlabIntegrationRepository_Expecter) Delete(tx interface{}, id interface{}) *GitlabIntegrationRepository_Delete_Call

+ func (_e *GitlabIntegrationRepository_Expecter) FindByOrganizationID(orgID interface{}) *GitlabIntegrationRepository_FindByOrganizationID_Call

+ func (_e *GitlabIntegrationRepository_Expecter) Read(id interface{}) *GitlabIntegrationRepository_Read_Call

+ func (_e *GitlabIntegrationRepository_Expecter) Save(tx interface{}, model interface{}) *GitlabIntegrationRepository_Save_Call

+ type GitlabIntegrationRepository_FindByOrganizationID_Call struct

+ func (_c *GitlabIntegrationRepository_FindByOrganizationID_Call) Return(gitLabIntegrations []models.GitLabIntegration, err error) *GitlabIntegrationRepository_FindByOrganizationID_Call

+ func (_c *GitlabIntegrationRepository_FindByOrganizationID_Call) Run(run func(orgID uuid.UUID)) *GitlabIntegrationRepository_FindByOrganizationID_Call

+ func (_c *GitlabIntegrationRepository_FindByOrganizationID_Call) RunAndReturn(run func(orgID uuid.UUID) ([]models.GitLabIntegration, error)) *GitlabIntegrationRepository_FindByOrganizationID_Call

+ type GitlabIntegrationRepository_Read_Call struct

+ func (_c *GitlabIntegrationRepository_Read_Call) Return(gitLabIntegration models.GitLabIntegration, err error) *GitlabIntegrationRepository_Read_Call

+ func (_c *GitlabIntegrationRepository_Read_Call) Run(run func(id uuid.UUID)) *GitlabIntegrationRepository_Read_Call

+ func (_c *GitlabIntegrationRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.GitLabIntegration, error)) *GitlabIntegrationRepository_Read_Call

+ type GitlabIntegrationRepository_Save_Call struct

+ func (_c *GitlabIntegrationRepository_Save_Call) Return(err error) *GitlabIntegrationRepository_Save_Call

+ func (_c *GitlabIntegrationRepository_Save_Call) Run(run func(tx core.DB, model *models.GitLabIntegration)) *GitlabIntegrationRepository_Save_Call

+ func (_c *GitlabIntegrationRepository_Save_Call) RunAndReturn(run func(tx core.DB, model *models.GitLabIntegration) error) *GitlabIntegrationRepository_Save_Call

+ type InTotoLinkRepository struct

+ func NewInTotoLinkRepository(t interface{ ... }) *InTotoLinkRepository

+ func (_m *InTotoLinkRepository) EXPECT() *InTotoLinkRepository_Expecter

+ func (_mock *InTotoLinkRepository) Activate(tx core.DB, id uuid.UUID) error

+ func (_mock *InTotoLinkRepository) All() ([]models.InTotoLink, error)

+ func (_mock *InTotoLinkRepository) Begin() core.DB

+ func (_mock *InTotoLinkRepository) Create(tx core.DB, t *models.InTotoLink) error

+ func (_mock *InTotoLinkRepository) CreateBatch(tx core.DB, ts []models.InTotoLink) error

+ func (_mock *InTotoLinkRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *InTotoLinkRepository) DeleteBatch(tx core.DB, ids []models.InTotoLink) error

+ func (_mock *InTotoLinkRepository) FindByAssetAndSupplyChainID(assetID uuid.UUID, supplyChainID string) ([]models.InTotoLink, error)

+ func (_mock *InTotoLinkRepository) FindBySupplyChainID(supplyChainID string) ([]models.InTotoLink, error)

+ func (_mock *InTotoLinkRepository) GetDB(tx core.DB) core.DB

+ func (_mock *InTotoLinkRepository) List(ids []uuid.UUID) ([]models.InTotoLink, error)

+ func (_mock *InTotoLinkRepository) Read(id uuid.UUID) (models.InTotoLink, error)

+ func (_mock *InTotoLinkRepository) Save(tx core.DB, model *models.InTotoLink) error

+ func (_mock *InTotoLinkRepository) SaveBatch(tx core.DB, ts []models.InTotoLink) error

+ func (_mock *InTotoLinkRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *InTotoLinkRepository) Upsert(t *[]*models.InTotoLink, conflictingColumns []clause.Column, ...) error

+ type InTotoLinkRepository_Activate_Call struct

+ func (_c *InTotoLinkRepository_Activate_Call) Return(err error) *InTotoLinkRepository_Activate_Call

+ func (_c *InTotoLinkRepository_Activate_Call) Run(run func(tx core.DB, id uuid.UUID)) *InTotoLinkRepository_Activate_Call

+ func (_c *InTotoLinkRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *InTotoLinkRepository_Activate_Call

+ type InTotoLinkRepository_All_Call struct

+ func (_c *InTotoLinkRepository_All_Call) Return(inTotoLinks []models.InTotoLink, err error) *InTotoLinkRepository_All_Call

+ func (_c *InTotoLinkRepository_All_Call) Run(run func()) *InTotoLinkRepository_All_Call

+ func (_c *InTotoLinkRepository_All_Call) RunAndReturn(run func() ([]models.InTotoLink, error)) *InTotoLinkRepository_All_Call

+ type InTotoLinkRepository_Begin_Call struct

+ func (_c *InTotoLinkRepository_Begin_Call) Return(v core.DB) *InTotoLinkRepository_Begin_Call

+ func (_c *InTotoLinkRepository_Begin_Call) Run(run func()) *InTotoLinkRepository_Begin_Call

+ func (_c *InTotoLinkRepository_Begin_Call) RunAndReturn(run func() core.DB) *InTotoLinkRepository_Begin_Call

+ type InTotoLinkRepository_CreateBatch_Call struct

+ func (_c *InTotoLinkRepository_CreateBatch_Call) Return(err error) *InTotoLinkRepository_CreateBatch_Call

+ func (_c *InTotoLinkRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.InTotoLink)) *InTotoLinkRepository_CreateBatch_Call

+ func (_c *InTotoLinkRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.InTotoLink) error) *InTotoLinkRepository_CreateBatch_Call

+ type InTotoLinkRepository_Create_Call struct

+ func (_c *InTotoLinkRepository_Create_Call) Return(err error) *InTotoLinkRepository_Create_Call

+ func (_c *InTotoLinkRepository_Create_Call) Run(run func(tx core.DB, t *models.InTotoLink)) *InTotoLinkRepository_Create_Call

+ func (_c *InTotoLinkRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.InTotoLink) error) *InTotoLinkRepository_Create_Call

+ type InTotoLinkRepository_DeleteBatch_Call struct

+ func (_c *InTotoLinkRepository_DeleteBatch_Call) Return(err error) *InTotoLinkRepository_DeleteBatch_Call

+ func (_c *InTotoLinkRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.InTotoLink)) *InTotoLinkRepository_DeleteBatch_Call

+ func (_c *InTotoLinkRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.InTotoLink) error) *InTotoLinkRepository_DeleteBatch_Call

+ type InTotoLinkRepository_Delete_Call struct

+ func (_c *InTotoLinkRepository_Delete_Call) Return(err error) *InTotoLinkRepository_Delete_Call

+ func (_c *InTotoLinkRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *InTotoLinkRepository_Delete_Call

+ func (_c *InTotoLinkRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *InTotoLinkRepository_Delete_Call

+ type InTotoLinkRepository_Expecter struct

+ func (_e *InTotoLinkRepository_Expecter) Activate(tx interface{}, id interface{}) *InTotoLinkRepository_Activate_Call

+ func (_e *InTotoLinkRepository_Expecter) All() *InTotoLinkRepository_All_Call

+ func (_e *InTotoLinkRepository_Expecter) Begin() *InTotoLinkRepository_Begin_Call

+ func (_e *InTotoLinkRepository_Expecter) Create(tx interface{}, t interface{}) *InTotoLinkRepository_Create_Call

+ func (_e *InTotoLinkRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *InTotoLinkRepository_CreateBatch_Call

+ func (_e *InTotoLinkRepository_Expecter) Delete(tx interface{}, id interface{}) *InTotoLinkRepository_Delete_Call

+ func (_e *InTotoLinkRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *InTotoLinkRepository_DeleteBatch_Call

+ func (_e *InTotoLinkRepository_Expecter) FindByAssetAndSupplyChainID(assetID interface{}, supplyChainID interface{}) *InTotoLinkRepository_FindByAssetAndSupplyChainID_Call

+ func (_e *InTotoLinkRepository_Expecter) FindBySupplyChainID(supplyChainID interface{}) *InTotoLinkRepository_FindBySupplyChainID_Call

+ func (_e *InTotoLinkRepository_Expecter) GetDB(tx interface{}) *InTotoLinkRepository_GetDB_Call

+ func (_e *InTotoLinkRepository_Expecter) List(ids interface{}) *InTotoLinkRepository_List_Call

+ func (_e *InTotoLinkRepository_Expecter) Read(id interface{}) *InTotoLinkRepository_Read_Call

+ func (_e *InTotoLinkRepository_Expecter) Save(tx interface{}, model interface{}) *InTotoLinkRepository_Save_Call

+ func (_e *InTotoLinkRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *InTotoLinkRepository_SaveBatch_Call

+ func (_e *InTotoLinkRepository_Expecter) Transaction(fn interface{}) *InTotoLinkRepository_Transaction_Call

+ func (_e *InTotoLinkRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *InTotoLinkRepository_Upsert_Call

+ type InTotoLinkRepository_FindByAssetAndSupplyChainID_Call struct

+ func (_c *InTotoLinkRepository_FindByAssetAndSupplyChainID_Call) Return(inTotoLinks []models.InTotoLink, err error) *InTotoLinkRepository_FindByAssetAndSupplyChainID_Call

+ func (_c *InTotoLinkRepository_FindByAssetAndSupplyChainID_Call) Run(run func(assetID uuid.UUID, supplyChainID string)) *InTotoLinkRepository_FindByAssetAndSupplyChainID_Call

+ func (_c *InTotoLinkRepository_FindByAssetAndSupplyChainID_Call) RunAndReturn(run func(assetID uuid.UUID, supplyChainID string) ([]models.InTotoLink, error)) *InTotoLinkRepository_FindByAssetAndSupplyChainID_Call

+ type InTotoLinkRepository_FindBySupplyChainID_Call struct

+ func (_c *InTotoLinkRepository_FindBySupplyChainID_Call) Return(inTotoLinks []models.InTotoLink, err error) *InTotoLinkRepository_FindBySupplyChainID_Call

+ func (_c *InTotoLinkRepository_FindBySupplyChainID_Call) Run(run func(supplyChainID string)) *InTotoLinkRepository_FindBySupplyChainID_Call

+ func (_c *InTotoLinkRepository_FindBySupplyChainID_Call) RunAndReturn(run func(supplyChainID string) ([]models.InTotoLink, error)) *InTotoLinkRepository_FindBySupplyChainID_Call

+ type InTotoLinkRepository_GetDB_Call struct

+ func (_c *InTotoLinkRepository_GetDB_Call) Return(v core.DB) *InTotoLinkRepository_GetDB_Call

+ func (_c *InTotoLinkRepository_GetDB_Call) Run(run func(tx core.DB)) *InTotoLinkRepository_GetDB_Call

+ func (_c *InTotoLinkRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *InTotoLinkRepository_GetDB_Call

+ type InTotoLinkRepository_List_Call struct

+ func (_c *InTotoLinkRepository_List_Call) Return(inTotoLinks []models.InTotoLink, err error) *InTotoLinkRepository_List_Call

+ func (_c *InTotoLinkRepository_List_Call) Run(run func(ids []uuid.UUID)) *InTotoLinkRepository_List_Call

+ func (_c *InTotoLinkRepository_List_Call) RunAndReturn(run func(ids []uuid.UUID) ([]models.InTotoLink, error)) *InTotoLinkRepository_List_Call

+ type InTotoLinkRepository_Read_Call struct

+ func (_c *InTotoLinkRepository_Read_Call) Return(inTotoLink models.InTotoLink, err error) *InTotoLinkRepository_Read_Call

+ func (_c *InTotoLinkRepository_Read_Call) Run(run func(id uuid.UUID)) *InTotoLinkRepository_Read_Call

+ func (_c *InTotoLinkRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.InTotoLink, error)) *InTotoLinkRepository_Read_Call

+ type InTotoLinkRepository_SaveBatch_Call struct

+ func (_c *InTotoLinkRepository_SaveBatch_Call) Return(err error) *InTotoLinkRepository_SaveBatch_Call

+ func (_c *InTotoLinkRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.InTotoLink)) *InTotoLinkRepository_SaveBatch_Call

+ func (_c *InTotoLinkRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.InTotoLink) error) *InTotoLinkRepository_SaveBatch_Call

+ type InTotoLinkRepository_Save_Call struct

+ func (_c *InTotoLinkRepository_Save_Call) Return(err error) *InTotoLinkRepository_Save_Call

+ func (_c *InTotoLinkRepository_Save_Call) Run(run func(tx core.DB, model *models.InTotoLink)) *InTotoLinkRepository_Save_Call

+ func (_c *InTotoLinkRepository_Save_Call) RunAndReturn(run func(tx core.DB, model *models.InTotoLink) error) *InTotoLinkRepository_Save_Call

+ type InTotoLinkRepository_Transaction_Call struct

+ func (_c *InTotoLinkRepository_Transaction_Call) Return(err error) *InTotoLinkRepository_Transaction_Call

+ func (_c *InTotoLinkRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *InTotoLinkRepository_Transaction_Call

+ func (_c *InTotoLinkRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *InTotoLinkRepository_Transaction_Call

+ type InTotoLinkRepository_Upsert_Call struct

+ func (_c *InTotoLinkRepository_Upsert_Call) Return(err error) *InTotoLinkRepository_Upsert_Call

+ func (_c *InTotoLinkRepository_Upsert_Call) Run(run func(t *[]*models.InTotoLink, conflictingColumns []clause.Column, ...)) *InTotoLinkRepository_Upsert_Call

+ func (_c *InTotoLinkRepository_Upsert_Call) RunAndReturn(...) *InTotoLinkRepository_Upsert_Call

+ type InTotoVerifierService struct

+ func NewInTotoVerifierService(t interface{ ... }) *InTotoVerifierService

+ func (_m *InTotoVerifierService) EXPECT() *InTotoVerifierService_Expecter

+ func (_mock *InTotoVerifierService) VerifySupplyChain(supplyChainID string) (bool, error)

+ func (_mock *InTotoVerifierService) VerifySupplyChainByDigestOnly(digest string) (bool, error)

+ func (_mock *InTotoVerifierService) VerifySupplyChainWithOutputDigest(supplyChainID string, digest string) (bool, error)

+ type InTotoVerifierService_Expecter struct

+ func (_e *InTotoVerifierService_Expecter) VerifySupplyChain(supplyChainID interface{}) *InTotoVerifierService_VerifySupplyChain_Call

+ func (_e *InTotoVerifierService_Expecter) VerifySupplyChainByDigestOnly(digest interface{}) *InTotoVerifierService_VerifySupplyChainByDigestOnly_Call

+ func (_e *InTotoVerifierService_Expecter) VerifySupplyChainWithOutputDigest(supplyChainID interface{}, digest interface{}) *InTotoVerifierService_VerifySupplyChainWithOutputDigest_Call

+ type InTotoVerifierService_VerifySupplyChainByDigestOnly_Call struct

+ func (_c *InTotoVerifierService_VerifySupplyChainByDigestOnly_Call) Return(b bool, err error) *InTotoVerifierService_VerifySupplyChainByDigestOnly_Call

+ func (_c *InTotoVerifierService_VerifySupplyChainByDigestOnly_Call) Run(run func(digest string)) *InTotoVerifierService_VerifySupplyChainByDigestOnly_Call

+ func (_c *InTotoVerifierService_VerifySupplyChainByDigestOnly_Call) RunAndReturn(run func(digest string) (bool, error)) *InTotoVerifierService_VerifySupplyChainByDigestOnly_Call

+ type InTotoVerifierService_VerifySupplyChainWithOutputDigest_Call struct

+ func (_c *InTotoVerifierService_VerifySupplyChainWithOutputDigest_Call) Return(b bool, err error) *InTotoVerifierService_VerifySupplyChainWithOutputDigest_Call

+ func (_c *InTotoVerifierService_VerifySupplyChainWithOutputDigest_Call) Run(run func(supplyChainID string, digest string)) *InTotoVerifierService_VerifySupplyChainWithOutputDigest_Call

+ func (_c *InTotoVerifierService_VerifySupplyChainWithOutputDigest_Call) RunAndReturn(run func(supplyChainID string, digest string) (bool, error)) *InTotoVerifierService_VerifySupplyChainWithOutputDigest_Call

+ type InTotoVerifierService_VerifySupplyChain_Call struct

+ func (_c *InTotoVerifierService_VerifySupplyChain_Call) Return(b bool, err error) *InTotoVerifierService_VerifySupplyChain_Call

+ func (_c *InTotoVerifierService_VerifySupplyChain_Call) Run(run func(supplyChainID string)) *InTotoVerifierService_VerifySupplyChain_Call

+ func (_c *InTotoVerifierService_VerifySupplyChain_Call) RunAndReturn(run func(supplyChainID string) (bool, error)) *InTotoVerifierService_VerifySupplyChain_Call

+ type IntegrationAggregate struct

+ func NewIntegrationAggregate(t interface{ ... }) *IntegrationAggregate

+ func (_m *IntegrationAggregate) EXPECT() *IntegrationAggregate_Expecter

+ func (_mock *IntegrationAggregate) CreateIssue(ctx context.Context, asset models.Asset, assetVersionName string, ...) error

+ func (_mock *IntegrationAggregate) GetID() core.IntegrationID

+ func (_mock *IntegrationAggregate) GetIntegration(id core.IntegrationID) core.ThirdPartyIntegration

+ func (_mock *IntegrationAggregate) GetUsers(org models.Org) []core.User

+ func (_mock *IntegrationAggregate) HandleEvent(event any) error

+ func (_mock *IntegrationAggregate) HandleWebhook(ctx core.Context) error

+ func (_mock *IntegrationAggregate) HasAccessToExternalEntityProvider(ctx core.Context, externalEntityProviderID string) (bool, error)

+ func (_mock *IntegrationAggregate) ListGroups(ctx context.Context, userID string, providerID string) ([]models.Project, []core.Role, error)

+ func (_mock *IntegrationAggregate) ListOrgs(ctx core.Context) ([]models.Org, error)

+ func (_mock *IntegrationAggregate) ListProjects(ctx context.Context, userID string, providerID string, groupID string) ([]models.Asset, []core.Role, error)

+ func (_mock *IntegrationAggregate) ListRepositories(ctx core.Context) ([]core.Repository, error)

+ func (_mock *IntegrationAggregate) UpdateIssue(ctx context.Context, asset models.Asset, vuln models.Vuln) error

+ func (_mock *IntegrationAggregate) WantsToHandleWebhook(ctx core.Context) bool

+ type IntegrationAggregate_CreateIssue_Call struct

+ func (_c *IntegrationAggregate_CreateIssue_Call) Return(err error) *IntegrationAggregate_CreateIssue_Call

+ func (_c *IntegrationAggregate_CreateIssue_Call) Run(...) *IntegrationAggregate_CreateIssue_Call

+ func (_c *IntegrationAggregate_CreateIssue_Call) RunAndReturn(...) *IntegrationAggregate_CreateIssue_Call

+ type IntegrationAggregate_Expecter struct

+ func (_e *IntegrationAggregate_Expecter) CreateIssue(ctx interface{}, asset interface{}, assetVersionName interface{}, ...) *IntegrationAggregate_CreateIssue_Call

+ func (_e *IntegrationAggregate_Expecter) GetID() *IntegrationAggregate_GetID_Call

+ func (_e *IntegrationAggregate_Expecter) GetIntegration(id interface{}) *IntegrationAggregate_GetIntegration_Call

+ func (_e *IntegrationAggregate_Expecter) GetUsers(org interface{}) *IntegrationAggregate_GetUsers_Call

+ func (_e *IntegrationAggregate_Expecter) HandleEvent(event interface{}) *IntegrationAggregate_HandleEvent_Call

+ func (_e *IntegrationAggregate_Expecter) HandleWebhook(ctx interface{}) *IntegrationAggregate_HandleWebhook_Call

+ func (_e *IntegrationAggregate_Expecter) HasAccessToExternalEntityProvider(ctx interface{}, externalEntityProviderID interface{}) *IntegrationAggregate_HasAccessToExternalEntityProvider_Call

+ func (_e *IntegrationAggregate_Expecter) ListGroups(ctx interface{}, userID interface{}, providerID interface{}) *IntegrationAggregate_ListGroups_Call

+ func (_e *IntegrationAggregate_Expecter) ListOrgs(ctx interface{}) *IntegrationAggregate_ListOrgs_Call

+ func (_e *IntegrationAggregate_Expecter) ListProjects(ctx interface{}, userID interface{}, providerID interface{}, ...) *IntegrationAggregate_ListProjects_Call

+ func (_e *IntegrationAggregate_Expecter) ListRepositories(ctx interface{}) *IntegrationAggregate_ListRepositories_Call

+ func (_e *IntegrationAggregate_Expecter) UpdateIssue(ctx interface{}, asset interface{}, vuln interface{}) *IntegrationAggregate_UpdateIssue_Call

+ func (_e *IntegrationAggregate_Expecter) WantsToHandleWebhook(ctx interface{}) *IntegrationAggregate_WantsToHandleWebhook_Call

+ type IntegrationAggregate_GetID_Call struct

+ func (_c *IntegrationAggregate_GetID_Call) Return(integrationID core.IntegrationID) *IntegrationAggregate_GetID_Call

+ func (_c *IntegrationAggregate_GetID_Call) Run(run func()) *IntegrationAggregate_GetID_Call

+ func (_c *IntegrationAggregate_GetID_Call) RunAndReturn(run func() core.IntegrationID) *IntegrationAggregate_GetID_Call

+ type IntegrationAggregate_GetIntegration_Call struct

+ func (_c *IntegrationAggregate_GetIntegration_Call) Return(thirdPartyIntegration core.ThirdPartyIntegration) *IntegrationAggregate_GetIntegration_Call

+ func (_c *IntegrationAggregate_GetIntegration_Call) Run(run func(id core.IntegrationID)) *IntegrationAggregate_GetIntegration_Call

+ func (_c *IntegrationAggregate_GetIntegration_Call) RunAndReturn(run func(id core.IntegrationID) core.ThirdPartyIntegration) *IntegrationAggregate_GetIntegration_Call

+ type IntegrationAggregate_GetUsers_Call struct

+ func (_c *IntegrationAggregate_GetUsers_Call) Return(users []core.User) *IntegrationAggregate_GetUsers_Call

+ func (_c *IntegrationAggregate_GetUsers_Call) Run(run func(org models.Org)) *IntegrationAggregate_GetUsers_Call

+ func (_c *IntegrationAggregate_GetUsers_Call) RunAndReturn(run func(org models.Org) []core.User) *IntegrationAggregate_GetUsers_Call

+ type IntegrationAggregate_HandleEvent_Call struct

+ func (_c *IntegrationAggregate_HandleEvent_Call) Return(err error) *IntegrationAggregate_HandleEvent_Call

+ func (_c *IntegrationAggregate_HandleEvent_Call) Run(run func(event any)) *IntegrationAggregate_HandleEvent_Call

+ func (_c *IntegrationAggregate_HandleEvent_Call) RunAndReturn(run func(event any) error) *IntegrationAggregate_HandleEvent_Call

+ type IntegrationAggregate_HandleWebhook_Call struct

+ func (_c *IntegrationAggregate_HandleWebhook_Call) Return(err error) *IntegrationAggregate_HandleWebhook_Call

+ func (_c *IntegrationAggregate_HandleWebhook_Call) Run(run func(ctx core.Context)) *IntegrationAggregate_HandleWebhook_Call

+ func (_c *IntegrationAggregate_HandleWebhook_Call) RunAndReturn(run func(ctx core.Context) error) *IntegrationAggregate_HandleWebhook_Call

+ type IntegrationAggregate_HasAccessToExternalEntityProvider_Call struct

+ func (_c *IntegrationAggregate_HasAccessToExternalEntityProvider_Call) Return(b bool, err error) *IntegrationAggregate_HasAccessToExternalEntityProvider_Call

+ func (_c *IntegrationAggregate_HasAccessToExternalEntityProvider_Call) Run(run func(ctx core.Context, externalEntityProviderID string)) *IntegrationAggregate_HasAccessToExternalEntityProvider_Call

+ func (_c *IntegrationAggregate_HasAccessToExternalEntityProvider_Call) RunAndReturn(run func(ctx core.Context, externalEntityProviderID string) (bool, error)) *IntegrationAggregate_HasAccessToExternalEntityProvider_Call

+ type IntegrationAggregate_ListGroups_Call struct

+ func (_c *IntegrationAggregate_ListGroups_Call) Return(projects []models.Project, roles []core.Role, err error) *IntegrationAggregate_ListGroups_Call

+ func (_c *IntegrationAggregate_ListGroups_Call) Run(run func(ctx context.Context, userID string, providerID string)) *IntegrationAggregate_ListGroups_Call

+ func (_c *IntegrationAggregate_ListGroups_Call) RunAndReturn(...) *IntegrationAggregate_ListGroups_Call

+ type IntegrationAggregate_ListOrgs_Call struct

+ func (_c *IntegrationAggregate_ListOrgs_Call) Return(orgs []models.Org, err error) *IntegrationAggregate_ListOrgs_Call

+ func (_c *IntegrationAggregate_ListOrgs_Call) Run(run func(ctx core.Context)) *IntegrationAggregate_ListOrgs_Call

+ func (_c *IntegrationAggregate_ListOrgs_Call) RunAndReturn(run func(ctx core.Context) ([]models.Org, error)) *IntegrationAggregate_ListOrgs_Call

+ type IntegrationAggregate_ListProjects_Call struct

+ func (_c *IntegrationAggregate_ListProjects_Call) Return(assets []models.Asset, roles []core.Role, err error) *IntegrationAggregate_ListProjects_Call

+ func (_c *IntegrationAggregate_ListProjects_Call) Run(...) *IntegrationAggregate_ListProjects_Call

+ func (_c *IntegrationAggregate_ListProjects_Call) RunAndReturn(...) *IntegrationAggregate_ListProjects_Call

+ type IntegrationAggregate_ListRepositories_Call struct

+ func (_c *IntegrationAggregate_ListRepositories_Call) Return(repositorys []core.Repository, err error) *IntegrationAggregate_ListRepositories_Call

+ func (_c *IntegrationAggregate_ListRepositories_Call) Run(run func(ctx core.Context)) *IntegrationAggregate_ListRepositories_Call

+ func (_c *IntegrationAggregate_ListRepositories_Call) RunAndReturn(run func(ctx core.Context) ([]core.Repository, error)) *IntegrationAggregate_ListRepositories_Call

+ type IntegrationAggregate_UpdateIssue_Call struct

+ func (_c *IntegrationAggregate_UpdateIssue_Call) Return(err error) *IntegrationAggregate_UpdateIssue_Call

+ func (_c *IntegrationAggregate_UpdateIssue_Call) Run(run func(ctx context.Context, asset models.Asset, vuln models.Vuln)) *IntegrationAggregate_UpdateIssue_Call

+ func (_c *IntegrationAggregate_UpdateIssue_Call) RunAndReturn(run func(ctx context.Context, asset models.Asset, vuln models.Vuln) error) *IntegrationAggregate_UpdateIssue_Call

+ type IntegrationAggregate_WantsToHandleWebhook_Call struct

+ func (_c *IntegrationAggregate_WantsToHandleWebhook_Call) Return(b bool) *IntegrationAggregate_WantsToHandleWebhook_Call

+ func (_c *IntegrationAggregate_WantsToHandleWebhook_Call) Run(run func(ctx core.Context)) *IntegrationAggregate_WantsToHandleWebhook_Call

+ func (_c *IntegrationAggregate_WantsToHandleWebhook_Call) RunAndReturn(run func(ctx core.Context) bool) *IntegrationAggregate_WantsToHandleWebhook_Call

+ type InvitationRepository struct

+ func NewInvitationRepository(t interface{ ... }) *InvitationRepository

+ func (_m *InvitationRepository) EXPECT() *InvitationRepository_Expecter

+ func (_mock *InvitationRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *InvitationRepository) FindByCode(code string) (models.Invitation, error)

+ func (_mock *InvitationRepository) Save(tx core.DB, invitation *models.Invitation) error

+ type InvitationRepository_Delete_Call struct

+ func (_c *InvitationRepository_Delete_Call) Return(err error) *InvitationRepository_Delete_Call

+ func (_c *InvitationRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *InvitationRepository_Delete_Call

+ func (_c *InvitationRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *InvitationRepository_Delete_Call

+ type InvitationRepository_Expecter struct

+ func (_e *InvitationRepository_Expecter) Delete(tx interface{}, id interface{}) *InvitationRepository_Delete_Call

+ func (_e *InvitationRepository_Expecter) FindByCode(code interface{}) *InvitationRepository_FindByCode_Call

+ func (_e *InvitationRepository_Expecter) Save(tx interface{}, invitation interface{}) *InvitationRepository_Save_Call

+ type InvitationRepository_FindByCode_Call struct

+ func (_c *InvitationRepository_FindByCode_Call) Return(invitation models.Invitation, err error) *InvitationRepository_FindByCode_Call

+ func (_c *InvitationRepository_FindByCode_Call) Run(run func(code string)) *InvitationRepository_FindByCode_Call

+ func (_c *InvitationRepository_FindByCode_Call) RunAndReturn(run func(code string) (models.Invitation, error)) *InvitationRepository_FindByCode_Call

+ type InvitationRepository_Save_Call struct

+ func (_c *InvitationRepository_Save_Call) Return(err error) *InvitationRepository_Save_Call

+ func (_c *InvitationRepository_Save_Call) Run(run func(tx core.DB, invitation *models.Invitation)) *InvitationRepository_Save_Call

+ func (_c *InvitationRepository_Save_Call) RunAndReturn(run func(tx core.DB, invitation *models.Invitation) error) *InvitationRepository_Save_Call

+ type JiraIntegrationRepository struct

+ func NewJiraIntegrationRepository(t interface{ ... }) *JiraIntegrationRepository

+ func (_m *JiraIntegrationRepository) EXPECT() *JiraIntegrationRepository_Expecter

+ func (_mock *JiraIntegrationRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *JiraIntegrationRepository) FindByOrganizationID(orgID uuid.UUID) ([]models.JiraIntegration, error)

+ func (_mock *JiraIntegrationRepository) GetClientByIntegrationID(integrationID uuid.UUID) (models.JiraIntegration, error)

+ func (_mock *JiraIntegrationRepository) Read(id uuid.UUID) (models.JiraIntegration, error)

+ func (_mock *JiraIntegrationRepository) Save(tx core.DB, model *models.JiraIntegration) error

+ type JiraIntegrationRepository_Delete_Call struct

+ func (_c *JiraIntegrationRepository_Delete_Call) Return(err error) *JiraIntegrationRepository_Delete_Call

+ func (_c *JiraIntegrationRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *JiraIntegrationRepository_Delete_Call

+ func (_c *JiraIntegrationRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *JiraIntegrationRepository_Delete_Call

+ type JiraIntegrationRepository_Expecter struct

+ func (_e *JiraIntegrationRepository_Expecter) Delete(tx interface{}, id interface{}) *JiraIntegrationRepository_Delete_Call

+ func (_e *JiraIntegrationRepository_Expecter) FindByOrganizationID(orgID interface{}) *JiraIntegrationRepository_FindByOrganizationID_Call

+ func (_e *JiraIntegrationRepository_Expecter) GetClientByIntegrationID(integrationID interface{}) *JiraIntegrationRepository_GetClientByIntegrationID_Call

+ func (_e *JiraIntegrationRepository_Expecter) Read(id interface{}) *JiraIntegrationRepository_Read_Call

+ func (_e *JiraIntegrationRepository_Expecter) Save(tx interface{}, model interface{}) *JiraIntegrationRepository_Save_Call

+ type JiraIntegrationRepository_FindByOrganizationID_Call struct

+ func (_c *JiraIntegrationRepository_FindByOrganizationID_Call) Return(jiraIntegrations []models.JiraIntegration, err error) *JiraIntegrationRepository_FindByOrganizationID_Call

+ func (_c *JiraIntegrationRepository_FindByOrganizationID_Call) Run(run func(orgID uuid.UUID)) *JiraIntegrationRepository_FindByOrganizationID_Call

+ func (_c *JiraIntegrationRepository_FindByOrganizationID_Call) RunAndReturn(run func(orgID uuid.UUID) ([]models.JiraIntegration, error)) *JiraIntegrationRepository_FindByOrganizationID_Call

+ type JiraIntegrationRepository_GetClientByIntegrationID_Call struct

+ func (_c *JiraIntegrationRepository_GetClientByIntegrationID_Call) Return(jiraIntegration models.JiraIntegration, err error) *JiraIntegrationRepository_GetClientByIntegrationID_Call

+ func (_c *JiraIntegrationRepository_GetClientByIntegrationID_Call) Run(run func(integrationID uuid.UUID)) *JiraIntegrationRepository_GetClientByIntegrationID_Call

+ func (_c *JiraIntegrationRepository_GetClientByIntegrationID_Call) RunAndReturn(run func(integrationID uuid.UUID) (models.JiraIntegration, error)) *JiraIntegrationRepository_GetClientByIntegrationID_Call

+ type JiraIntegrationRepository_Read_Call struct

+ func (_c *JiraIntegrationRepository_Read_Call) Return(jiraIntegration models.JiraIntegration, err error) *JiraIntegrationRepository_Read_Call

+ func (_c *JiraIntegrationRepository_Read_Call) Run(run func(id uuid.UUID)) *JiraIntegrationRepository_Read_Call

+ func (_c *JiraIntegrationRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.JiraIntegration, error)) *JiraIntegrationRepository_Read_Call

+ type JiraIntegrationRepository_Save_Call struct

+ func (_c *JiraIntegrationRepository_Save_Call) Return(err error) *JiraIntegrationRepository_Save_Call

+ func (_c *JiraIntegrationRepository_Save_Call) Run(run func(tx core.DB, model *models.JiraIntegration)) *JiraIntegrationRepository_Save_Call

+ func (_c *JiraIntegrationRepository_Save_Call) RunAndReturn(run func(tx core.DB, model *models.JiraIntegration) error) *JiraIntegrationRepository_Save_Call

+ type LicenseRiskRepository struct

+ func NewLicenseRiskRepository(t interface{ ... }) *LicenseRiskRepository

+ func (_m *LicenseRiskRepository) EXPECT() *LicenseRiskRepository_Expecter

+ func (_mock *LicenseRiskRepository) Activate(tx core.DB, id string) error

+ func (_mock *LicenseRiskRepository) All() ([]models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) ApplyAndSave(tx core.DB, licenseRisk *models.LicenseRisk, vulnEvent *models.VulnEvent) error

+ func (_mock *LicenseRiskRepository) Begin() core.DB

+ func (_mock *LicenseRiskRepository) Create(tx core.DB, t *models.LicenseRisk) error

+ func (_mock *LicenseRiskRepository) CreateBatch(tx core.DB, ts []models.LicenseRisk) error

+ func (_mock *LicenseRiskRepository) Delete(tx core.DB, id string) error

+ func (_mock *LicenseRiskRepository) DeleteBatch(tx core.DB, ids []models.LicenseRisk) error

+ func (_mock *LicenseRiskRepository) DeleteByComponentPurl(assetID uuid.UUID, assetVersionName string, purl packageurl.PackageURL) error

+ func (_mock *LicenseRiskRepository) GetAllLicenseRisksForAssetVersion(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) GetAllLicenseRisksForAssetVersionPaged(tx core.DB, assetID uuid.UUID, assetVersionName string, pageInfo core.PageInfo, ...) (core.Paged[models.LicenseRisk], error)

+ func (_mock *LicenseRiskRepository) GetAllOverwrittenLicensesForAssetVersion(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) GetDB(tx core.DB) core.DB

+ func (_mock *LicenseRiskRepository) GetLicenseRisksByOtherAssetVersions(tx core.DB, assetVersionName string, assetID uuid.UUID) ([]models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) List(ids []string) ([]models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) ListByArtifactName(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) MaybeGetLicenseOverwriteForComponent(assetID uuid.UUID, assetVersionName string, pURL packageurl.PackageURL) (models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) Read(id string) (models.LicenseRisk, error)

+ func (_mock *LicenseRiskRepository) Save(tx core.DB, t *models.LicenseRisk) error

+ func (_mock *LicenseRiskRepository) SaveBatch(tx core.DB, ts []models.LicenseRisk) error

+ func (_mock *LicenseRiskRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *LicenseRiskRepository) Upsert(t *[]*models.LicenseRisk, conflictingColumns []clause.Column, ...) error

+ type LicenseRiskRepository_Activate_Call struct

+ func (_c *LicenseRiskRepository_Activate_Call) Return(err error) *LicenseRiskRepository_Activate_Call

+ func (_c *LicenseRiskRepository_Activate_Call) Run(run func(tx core.DB, id string)) *LicenseRiskRepository_Activate_Call

+ func (_c *LicenseRiskRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *LicenseRiskRepository_Activate_Call

+ type LicenseRiskRepository_All_Call struct

+ func (_c *LicenseRiskRepository_All_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_All_Call

+ func (_c *LicenseRiskRepository_All_Call) Run(run func()) *LicenseRiskRepository_All_Call

+ func (_c *LicenseRiskRepository_All_Call) RunAndReturn(run func() ([]models.LicenseRisk, error)) *LicenseRiskRepository_All_Call

+ type LicenseRiskRepository_ApplyAndSave_Call struct

+ func (_c *LicenseRiskRepository_ApplyAndSave_Call) Return(err error) *LicenseRiskRepository_ApplyAndSave_Call

+ func (_c *LicenseRiskRepository_ApplyAndSave_Call) Run(...) *LicenseRiskRepository_ApplyAndSave_Call

+ func (_c *LicenseRiskRepository_ApplyAndSave_Call) RunAndReturn(...) *LicenseRiskRepository_ApplyAndSave_Call

+ type LicenseRiskRepository_Begin_Call struct

+ func (_c *LicenseRiskRepository_Begin_Call) Return(v core.DB) *LicenseRiskRepository_Begin_Call

+ func (_c *LicenseRiskRepository_Begin_Call) Run(run func()) *LicenseRiskRepository_Begin_Call

+ func (_c *LicenseRiskRepository_Begin_Call) RunAndReturn(run func() core.DB) *LicenseRiskRepository_Begin_Call

+ type LicenseRiskRepository_CreateBatch_Call struct

+ func (_c *LicenseRiskRepository_CreateBatch_Call) Return(err error) *LicenseRiskRepository_CreateBatch_Call

+ func (_c *LicenseRiskRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.LicenseRisk)) *LicenseRiskRepository_CreateBatch_Call

+ func (_c *LicenseRiskRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.LicenseRisk) error) *LicenseRiskRepository_CreateBatch_Call

+ type LicenseRiskRepository_Create_Call struct

+ func (_c *LicenseRiskRepository_Create_Call) Return(err error) *LicenseRiskRepository_Create_Call

+ func (_c *LicenseRiskRepository_Create_Call) Run(run func(tx core.DB, t *models.LicenseRisk)) *LicenseRiskRepository_Create_Call

+ func (_c *LicenseRiskRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.LicenseRisk) error) *LicenseRiskRepository_Create_Call

+ type LicenseRiskRepository_DeleteBatch_Call struct

+ func (_c *LicenseRiskRepository_DeleteBatch_Call) Return(err error) *LicenseRiskRepository_DeleteBatch_Call

+ func (_c *LicenseRiskRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.LicenseRisk)) *LicenseRiskRepository_DeleteBatch_Call

+ func (_c *LicenseRiskRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.LicenseRisk) error) *LicenseRiskRepository_DeleteBatch_Call

+ type LicenseRiskRepository_DeleteByComponentPurl_Call struct

+ func (_c *LicenseRiskRepository_DeleteByComponentPurl_Call) Return(err error) *LicenseRiskRepository_DeleteByComponentPurl_Call

+ func (_c *LicenseRiskRepository_DeleteByComponentPurl_Call) Run(...) *LicenseRiskRepository_DeleteByComponentPurl_Call

+ func (_c *LicenseRiskRepository_DeleteByComponentPurl_Call) RunAndReturn(...) *LicenseRiskRepository_DeleteByComponentPurl_Call

+ type LicenseRiskRepository_Delete_Call struct

+ func (_c *LicenseRiskRepository_Delete_Call) Return(err error) *LicenseRiskRepository_Delete_Call

+ func (_c *LicenseRiskRepository_Delete_Call) Run(run func(tx core.DB, id string)) *LicenseRiskRepository_Delete_Call

+ func (_c *LicenseRiskRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *LicenseRiskRepository_Delete_Call

+ type LicenseRiskRepository_Expecter struct

+ func (_e *LicenseRiskRepository_Expecter) Activate(tx interface{}, id interface{}) *LicenseRiskRepository_Activate_Call

+ func (_e *LicenseRiskRepository_Expecter) All() *LicenseRiskRepository_All_Call

+ func (_e *LicenseRiskRepository_Expecter) ApplyAndSave(tx interface{}, licenseRisk interface{}, vulnEvent interface{}) *LicenseRiskRepository_ApplyAndSave_Call

+ func (_e *LicenseRiskRepository_Expecter) Begin() *LicenseRiskRepository_Begin_Call

+ func (_e *LicenseRiskRepository_Expecter) Create(tx interface{}, t interface{}) *LicenseRiskRepository_Create_Call

+ func (_e *LicenseRiskRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *LicenseRiskRepository_CreateBatch_Call

+ func (_e *LicenseRiskRepository_Expecter) Delete(tx interface{}, id interface{}) *LicenseRiskRepository_Delete_Call

+ func (_e *LicenseRiskRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *LicenseRiskRepository_DeleteBatch_Call

+ func (_e *LicenseRiskRepository_Expecter) DeleteByComponentPurl(assetID interface{}, assetVersionName interface{}, purl interface{}) *LicenseRiskRepository_DeleteByComponentPurl_Call

+ func (_e *LicenseRiskRepository_Expecter) GetAllLicenseRisksForAssetVersion(assetID interface{}, assetVersionName interface{}) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call

+ func (_e *LicenseRiskRepository_Expecter) GetAllLicenseRisksForAssetVersionPaged(tx interface{}, assetID interface{}, assetVersionName interface{}, ...) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call

+ func (_e *LicenseRiskRepository_Expecter) GetAllOverwrittenLicensesForAssetVersion(assetID interface{}, assetVersionName interface{}) *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call

+ func (_e *LicenseRiskRepository_Expecter) GetDB(tx interface{}) *LicenseRiskRepository_GetDB_Call

+ func (_e *LicenseRiskRepository_Expecter) GetLicenseRisksByOtherAssetVersions(tx interface{}, assetVersionName interface{}, assetID interface{}) *LicenseRiskRepository_GetLicenseRisksByOtherAssetVersions_Call

+ func (_e *LicenseRiskRepository_Expecter) List(ids interface{}) *LicenseRiskRepository_List_Call

+ func (_e *LicenseRiskRepository_Expecter) ListByArtifactName(assetVersionName interface{}, assetID interface{}, scannerID interface{}) *LicenseRiskRepository_ListByArtifactName_Call

+ func (_e *LicenseRiskRepository_Expecter) MaybeGetLicenseOverwriteForComponent(assetID interface{}, assetVersionName interface{}, pURL interface{}) *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call

+ func (_e *LicenseRiskRepository_Expecter) Read(id interface{}) *LicenseRiskRepository_Read_Call

+ func (_e *LicenseRiskRepository_Expecter) Save(tx interface{}, t interface{}) *LicenseRiskRepository_Save_Call

+ func (_e *LicenseRiskRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *LicenseRiskRepository_SaveBatch_Call

+ func (_e *LicenseRiskRepository_Expecter) Transaction(fn interface{}) *LicenseRiskRepository_Transaction_Call

+ func (_e *LicenseRiskRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *LicenseRiskRepository_Upsert_Call

+ type LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call struct

+ func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call) Return(paged core.Paged[models.LicenseRisk], err error) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call

+ func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call) Run(...) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call

+ func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call) RunAndReturn(...) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call

+ type LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call struct

+ func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call

+ func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call) Run(run func(assetID uuid.UUID, assetVersionName string)) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call

+ func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call) RunAndReturn(...) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call

+ type LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call struct

+ func (_c *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call

+ func (_c *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call) Run(run func(assetID uuid.UUID, assetVersionName string)) *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call

+ func (_c *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call) RunAndReturn(...) *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call

+ type LicenseRiskRepository_GetDB_Call struct

+ func (_c *LicenseRiskRepository_GetDB_Call) Return(v core.DB) *LicenseRiskRepository_GetDB_Call

+ func (_c *LicenseRiskRepository_GetDB_Call) Run(run func(tx core.DB)) *LicenseRiskRepository_GetDB_Call

+ func (_c *LicenseRiskRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *LicenseRiskRepository_GetDB_Call

+ type LicenseRiskRepository_GetLicenseRisksByOtherAssetVersions_Call struct

+ func (_c *LicenseRiskRepository_GetLicenseRisksByOtherAssetVersions_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_GetLicenseRisksByOtherAssetVersions_Call

+ func (_c *LicenseRiskRepository_GetLicenseRisksByOtherAssetVersions_Call) Run(run func(tx core.DB, assetVersionName string, assetID uuid.UUID)) *LicenseRiskRepository_GetLicenseRisksByOtherAssetVersions_Call

+ func (_c *LicenseRiskRepository_GetLicenseRisksByOtherAssetVersions_Call) RunAndReturn(...) *LicenseRiskRepository_GetLicenseRisksByOtherAssetVersions_Call

+ type LicenseRiskRepository_ListByArtifactName_Call struct

+ func (_c *LicenseRiskRepository_ListByArtifactName_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_ListByArtifactName_Call

+ func (_c *LicenseRiskRepository_ListByArtifactName_Call) Run(run func(assetVersionName string, assetID uuid.UUID, scannerID string)) *LicenseRiskRepository_ListByArtifactName_Call

+ func (_c *LicenseRiskRepository_ListByArtifactName_Call) RunAndReturn(...) *LicenseRiskRepository_ListByArtifactName_Call

+ type LicenseRiskRepository_List_Call struct

+ func (_c *LicenseRiskRepository_List_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_List_Call

+ func (_c *LicenseRiskRepository_List_Call) Run(run func(ids []string)) *LicenseRiskRepository_List_Call

+ func (_c *LicenseRiskRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.LicenseRisk, error)) *LicenseRiskRepository_List_Call

+ type LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call struct

+ func (_c *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call) Return(licenseRisk models.LicenseRisk, err error) *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call

+ func (_c *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call) Run(...) *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call

+ func (_c *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call) RunAndReturn(...) *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call

+ type LicenseRiskRepository_Read_Call struct

+ func (_c *LicenseRiskRepository_Read_Call) Return(licenseRisk models.LicenseRisk, err error) *LicenseRiskRepository_Read_Call

+ func (_c *LicenseRiskRepository_Read_Call) Run(run func(id string)) *LicenseRiskRepository_Read_Call

+ func (_c *LicenseRiskRepository_Read_Call) RunAndReturn(run func(id string) (models.LicenseRisk, error)) *LicenseRiskRepository_Read_Call

+ type LicenseRiskRepository_SaveBatch_Call struct

+ func (_c *LicenseRiskRepository_SaveBatch_Call) Return(err error) *LicenseRiskRepository_SaveBatch_Call

+ func (_c *LicenseRiskRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.LicenseRisk)) *LicenseRiskRepository_SaveBatch_Call

+ func (_c *LicenseRiskRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.LicenseRisk) error) *LicenseRiskRepository_SaveBatch_Call

+ type LicenseRiskRepository_Save_Call struct

+ func (_c *LicenseRiskRepository_Save_Call) Return(err error) *LicenseRiskRepository_Save_Call

+ func (_c *LicenseRiskRepository_Save_Call) Run(run func(tx core.DB, t *models.LicenseRisk)) *LicenseRiskRepository_Save_Call

+ func (_c *LicenseRiskRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.LicenseRisk) error) *LicenseRiskRepository_Save_Call

+ type LicenseRiskRepository_Transaction_Call struct

+ func (_c *LicenseRiskRepository_Transaction_Call) Return(err error) *LicenseRiskRepository_Transaction_Call

+ func (_c *LicenseRiskRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *LicenseRiskRepository_Transaction_Call

+ func (_c *LicenseRiskRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *LicenseRiskRepository_Transaction_Call

+ type LicenseRiskRepository_Upsert_Call struct

+ func (_c *LicenseRiskRepository_Upsert_Call) Return(err error) *LicenseRiskRepository_Upsert_Call

+ func (_c *LicenseRiskRepository_Upsert_Call) Run(run func(t *[]*models.LicenseRisk, conflictingColumns []clause.Column, ...)) *LicenseRiskRepository_Upsert_Call

+ func (_c *LicenseRiskRepository_Upsert_Call) RunAndReturn(...) *LicenseRiskRepository_Upsert_Call

+ type LicenseRiskService struct

+ func NewLicenseRiskService(t interface{ ... }) *LicenseRiskService

+ func (_m *LicenseRiskService) EXPECT() *LicenseRiskService_Expecter

+ func (_mock *LicenseRiskService) FindLicenseRisksInComponents(assetVersion models.AssetVersion, components []models.Component, ...) error

+ func (_mock *LicenseRiskService) MakeFinalLicenseDecision(vulnID string, finalLicense string, justification string, userID string) error

+ func (_mock *LicenseRiskService) UpdateLicenseRiskState(tx core.DB, userID string, licenseRisk *models.LicenseRisk, statusType string, ...) (models.VulnEvent, error)

+ type LicenseRiskService_Expecter struct

+ func (_e *LicenseRiskService_Expecter) FindLicenseRisksInComponents(assetVersion interface{}, components interface{}, artifactName interface{}) *LicenseRiskService_FindLicenseRisksInComponents_Call

+ func (_e *LicenseRiskService_Expecter) MakeFinalLicenseDecision(vulnID interface{}, finalLicense interface{}, justification interface{}, ...) *LicenseRiskService_MakeFinalLicenseDecision_Call

+ func (_e *LicenseRiskService_Expecter) UpdateLicenseRiskState(tx interface{}, userID interface{}, licenseRisk interface{}, ...) *LicenseRiskService_UpdateLicenseRiskState_Call

+ type LicenseRiskService_FindLicenseRisksInComponents_Call struct

+ func (_c *LicenseRiskService_FindLicenseRisksInComponents_Call) Return(err error) *LicenseRiskService_FindLicenseRisksInComponents_Call

+ func (_c *LicenseRiskService_FindLicenseRisksInComponents_Call) Run(run func(assetVersion models.AssetVersion, components []models.Component, ...)) *LicenseRiskService_FindLicenseRisksInComponents_Call

+ func (_c *LicenseRiskService_FindLicenseRisksInComponents_Call) RunAndReturn(...) *LicenseRiskService_FindLicenseRisksInComponents_Call

+ type LicenseRiskService_MakeFinalLicenseDecision_Call struct

+ func (_c *LicenseRiskService_MakeFinalLicenseDecision_Call) Return(err error) *LicenseRiskService_MakeFinalLicenseDecision_Call

+ func (_c *LicenseRiskService_MakeFinalLicenseDecision_Call) Run(...) *LicenseRiskService_MakeFinalLicenseDecision_Call

+ func (_c *LicenseRiskService_MakeFinalLicenseDecision_Call) RunAndReturn(...) *LicenseRiskService_MakeFinalLicenseDecision_Call

+ type LicenseRiskService_UpdateLicenseRiskState_Call struct

+ func (_c *LicenseRiskService_UpdateLicenseRiskState_Call) Return(vulnEvent models.VulnEvent, err error) *LicenseRiskService_UpdateLicenseRiskState_Call

+ func (_c *LicenseRiskService_UpdateLicenseRiskState_Call) Run(...) *LicenseRiskService_UpdateLicenseRiskState_Call

+ func (_c *LicenseRiskService_UpdateLicenseRiskState_Call) RunAndReturn(...) *LicenseRiskService_UpdateLicenseRiskState_Call

+ type OpenSourceInsightService struct

+ func NewOpenSourceInsightService(t interface{ ... }) *OpenSourceInsightService

+ func (_m *OpenSourceInsightService) EXPECT() *OpenSourceInsightService_Expecter

+ func (_mock *OpenSourceInsightService) GetProject(ctx context.Context, projectID string) (common.OpenSourceInsightsProjectResponse, error)

+ func (_mock *OpenSourceInsightService) GetVersion(ctx context.Context, ecosystem string, packageName string, version string) (common.OpenSourceInsightsVersionResponse, error)

+ type OpenSourceInsightService_Expecter struct

+ func (_e *OpenSourceInsightService_Expecter) GetProject(ctx interface{}, projectID interface{}) *OpenSourceInsightService_GetProject_Call

+ func (_e *OpenSourceInsightService_Expecter) GetVersion(ctx interface{}, ecosystem interface{}, packageName interface{}, ...) *OpenSourceInsightService_GetVersion_Call

+ type OpenSourceInsightService_GetProject_Call struct

+ func (_c *OpenSourceInsightService_GetProject_Call) Return(openSourceInsightsProjectResponse common.OpenSourceInsightsProjectResponse, ...) *OpenSourceInsightService_GetProject_Call

+ func (_c *OpenSourceInsightService_GetProject_Call) Run(run func(ctx context.Context, projectID string)) *OpenSourceInsightService_GetProject_Call

+ func (_c *OpenSourceInsightService_GetProject_Call) RunAndReturn(...) *OpenSourceInsightService_GetProject_Call

+ type OpenSourceInsightService_GetVersion_Call struct

+ func (_c *OpenSourceInsightService_GetVersion_Call) Return(openSourceInsightsVersionResponse common.OpenSourceInsightsVersionResponse, ...) *OpenSourceInsightService_GetVersion_Call

+ func (_c *OpenSourceInsightService_GetVersion_Call) Run(...) *OpenSourceInsightService_GetVersion_Call

+ func (_c *OpenSourceInsightService_GetVersion_Call) RunAndReturn(...) *OpenSourceInsightService_GetVersion_Call

+ type OrgService struct

+ func NewOrgService(t interface{ ... }) *OrgService

+ func (_m *OrgService) EXPECT() *OrgService_Expecter

+ func (_mock *OrgService) CreateOrganization(ctx core.Context, organization *models.Org) error

+ func (_mock *OrgService) ReadBySlug(slug string) (*models.Org, error)

+ type OrgService_CreateOrganization_Call struct

+ func (_c *OrgService_CreateOrganization_Call) Return(err error) *OrgService_CreateOrganization_Call

+ func (_c *OrgService_CreateOrganization_Call) Run(run func(ctx core.Context, organization *models.Org)) *OrgService_CreateOrganization_Call

+ func (_c *OrgService_CreateOrganization_Call) RunAndReturn(run func(ctx core.Context, organization *models.Org) error) *OrgService_CreateOrganization_Call

+ type OrgService_Expecter struct

+ func (_e *OrgService_Expecter) CreateOrganization(ctx interface{}, organization interface{}) *OrgService_CreateOrganization_Call

+ func (_e *OrgService_Expecter) ReadBySlug(slug interface{}) *OrgService_ReadBySlug_Call

+ type OrgService_ReadBySlug_Call struct

+ func (_c *OrgService_ReadBySlug_Call) Return(org *models.Org, err error) *OrgService_ReadBySlug_Call

+ func (_c *OrgService_ReadBySlug_Call) Run(run func(slug string)) *OrgService_ReadBySlug_Call

+ func (_c *OrgService_ReadBySlug_Call) RunAndReturn(run func(slug string) (*models.Org, error)) *OrgService_ReadBySlug_Call

+ type OrganizationRepository struct

+ func NewOrganizationRepository(t interface{ ... }) *OrganizationRepository

+ func (_m *OrganizationRepository) EXPECT() *OrganizationRepository_Expecter

+ func (_mock *OrganizationRepository) Activate(tx core.DB, id uuid.UUID) error

+ func (_mock *OrganizationRepository) All() ([]models.Org, error)

+ func (_mock *OrganizationRepository) Begin() core.DB

+ func (_mock *OrganizationRepository) ContentTree(orgID uuid.UUID, projects []string) []any

+ func (_mock *OrganizationRepository) Create(tx core.DB, t *models.Org) error

+ func (_mock *OrganizationRepository) CreateBatch(tx core.DB, ts []models.Org) error

+ func (_mock *OrganizationRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *OrganizationRepository) DeleteBatch(tx core.DB, ids []models.Org) error

+ func (_mock *OrganizationRepository) GetDB(tx core.DB) core.DB

+ func (_mock *OrganizationRepository) GetOrgByID(id uuid.UUID) (models.Org, error)

+ func (_mock *OrganizationRepository) List(ids []uuid.UUID) ([]models.Org, error)

+ func (_mock *OrganizationRepository) Read(id uuid.UUID) (models.Org, error)

+ func (_mock *OrganizationRepository) ReadBySlug(slug string) (models.Org, error)

+ func (_mock *OrganizationRepository) Save(tx core.DB, t *models.Org) error

+ func (_mock *OrganizationRepository) SaveBatch(tx core.DB, ts []models.Org) error

+ func (_mock *OrganizationRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *OrganizationRepository) Update(tx core.DB, organization *models.Org) error

+ func (_mock *OrganizationRepository) Upsert(t *[]*models.Org, conflictingColumns []clause.Column, updateOnly []string) error

+ type OrganizationRepository_Activate_Call struct

+ func (_c *OrganizationRepository_Activate_Call) Return(err error) *OrganizationRepository_Activate_Call

+ func (_c *OrganizationRepository_Activate_Call) Run(run func(tx core.DB, id uuid.UUID)) *OrganizationRepository_Activate_Call

+ func (_c *OrganizationRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *OrganizationRepository_Activate_Call

+ type OrganizationRepository_All_Call struct

+ func (_c *OrganizationRepository_All_Call) Return(orgs []models.Org, err error) *OrganizationRepository_All_Call

+ func (_c *OrganizationRepository_All_Call) Run(run func()) *OrganizationRepository_All_Call

+ func (_c *OrganizationRepository_All_Call) RunAndReturn(run func() ([]models.Org, error)) *OrganizationRepository_All_Call

+ type OrganizationRepository_Begin_Call struct

+ func (_c *OrganizationRepository_Begin_Call) Return(v core.DB) *OrganizationRepository_Begin_Call

+ func (_c *OrganizationRepository_Begin_Call) Run(run func()) *OrganizationRepository_Begin_Call

+ func (_c *OrganizationRepository_Begin_Call) RunAndReturn(run func() core.DB) *OrganizationRepository_Begin_Call

+ type OrganizationRepository_ContentTree_Call struct

+ func (_c *OrganizationRepository_ContentTree_Call) Return(vs []any) *OrganizationRepository_ContentTree_Call

+ func (_c *OrganizationRepository_ContentTree_Call) Run(run func(orgID uuid.UUID, projects []string)) *OrganizationRepository_ContentTree_Call

+ func (_c *OrganizationRepository_ContentTree_Call) RunAndReturn(run func(orgID uuid.UUID, projects []string) []any) *OrganizationRepository_ContentTree_Call

+ type OrganizationRepository_CreateBatch_Call struct

+ func (_c *OrganizationRepository_CreateBatch_Call) Return(err error) *OrganizationRepository_CreateBatch_Call

+ func (_c *OrganizationRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.Org)) *OrganizationRepository_CreateBatch_Call

+ func (_c *OrganizationRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Org) error) *OrganizationRepository_CreateBatch_Call

+ type OrganizationRepository_Create_Call struct

+ func (_c *OrganizationRepository_Create_Call) Return(err error) *OrganizationRepository_Create_Call

+ func (_c *OrganizationRepository_Create_Call) Run(run func(tx core.DB, t *models.Org)) *OrganizationRepository_Create_Call

+ func (_c *OrganizationRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.Org) error) *OrganizationRepository_Create_Call

+ type OrganizationRepository_DeleteBatch_Call struct

+ func (_c *OrganizationRepository_DeleteBatch_Call) Return(err error) *OrganizationRepository_DeleteBatch_Call

+ func (_c *OrganizationRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.Org)) *OrganizationRepository_DeleteBatch_Call

+ func (_c *OrganizationRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.Org) error) *OrganizationRepository_DeleteBatch_Call

+ type OrganizationRepository_Delete_Call struct

+ func (_c *OrganizationRepository_Delete_Call) Return(err error) *OrganizationRepository_Delete_Call

+ func (_c *OrganizationRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *OrganizationRepository_Delete_Call

+ func (_c *OrganizationRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *OrganizationRepository_Delete_Call

+ type OrganizationRepository_Expecter struct

+ func (_e *OrganizationRepository_Expecter) Activate(tx interface{}, id interface{}) *OrganizationRepository_Activate_Call

+ func (_e *OrganizationRepository_Expecter) All() *OrganizationRepository_All_Call

+ func (_e *OrganizationRepository_Expecter) Begin() *OrganizationRepository_Begin_Call

+ func (_e *OrganizationRepository_Expecter) ContentTree(orgID interface{}, projects interface{}) *OrganizationRepository_ContentTree_Call

+ func (_e *OrganizationRepository_Expecter) Create(tx interface{}, t interface{}) *OrganizationRepository_Create_Call

+ func (_e *OrganizationRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *OrganizationRepository_CreateBatch_Call

+ func (_e *OrganizationRepository_Expecter) Delete(tx interface{}, id interface{}) *OrganizationRepository_Delete_Call

+ func (_e *OrganizationRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *OrganizationRepository_DeleteBatch_Call

+ func (_e *OrganizationRepository_Expecter) GetDB(tx interface{}) *OrganizationRepository_GetDB_Call

+ func (_e *OrganizationRepository_Expecter) GetOrgByID(id interface{}) *OrganizationRepository_GetOrgByID_Call

+ func (_e *OrganizationRepository_Expecter) List(ids interface{}) *OrganizationRepository_List_Call

+ func (_e *OrganizationRepository_Expecter) Read(id interface{}) *OrganizationRepository_Read_Call

+ func (_e *OrganizationRepository_Expecter) ReadBySlug(slug interface{}) *OrganizationRepository_ReadBySlug_Call

+ func (_e *OrganizationRepository_Expecter) Save(tx interface{}, t interface{}) *OrganizationRepository_Save_Call

+ func (_e *OrganizationRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *OrganizationRepository_SaveBatch_Call

+ func (_e *OrganizationRepository_Expecter) Transaction(fn interface{}) *OrganizationRepository_Transaction_Call

+ func (_e *OrganizationRepository_Expecter) Update(tx interface{}, organization interface{}) *OrganizationRepository_Update_Call

+ func (_e *OrganizationRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *OrganizationRepository_Upsert_Call

+ type OrganizationRepository_GetDB_Call struct

+ func (_c *OrganizationRepository_GetDB_Call) Return(v core.DB) *OrganizationRepository_GetDB_Call

+ func (_c *OrganizationRepository_GetDB_Call) Run(run func(tx core.DB)) *OrganizationRepository_GetDB_Call

+ func (_c *OrganizationRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *OrganizationRepository_GetDB_Call

+ type OrganizationRepository_GetOrgByID_Call struct

+ func (_c *OrganizationRepository_GetOrgByID_Call) Return(org models.Org, err error) *OrganizationRepository_GetOrgByID_Call

+ func (_c *OrganizationRepository_GetOrgByID_Call) Run(run func(id uuid.UUID)) *OrganizationRepository_GetOrgByID_Call

+ func (_c *OrganizationRepository_GetOrgByID_Call) RunAndReturn(run func(id uuid.UUID) (models.Org, error)) *OrganizationRepository_GetOrgByID_Call

+ type OrganizationRepository_List_Call struct

+ func (_c *OrganizationRepository_List_Call) Return(orgs []models.Org, err error) *OrganizationRepository_List_Call

+ func (_c *OrganizationRepository_List_Call) Run(run func(ids []uuid.UUID)) *OrganizationRepository_List_Call

+ func (_c *OrganizationRepository_List_Call) RunAndReturn(run func(ids []uuid.UUID) ([]models.Org, error)) *OrganizationRepository_List_Call

+ type OrganizationRepository_ReadBySlug_Call struct

+ func (_c *OrganizationRepository_ReadBySlug_Call) Return(org models.Org, err error) *OrganizationRepository_ReadBySlug_Call

+ func (_c *OrganizationRepository_ReadBySlug_Call) Run(run func(slug string)) *OrganizationRepository_ReadBySlug_Call

+ func (_c *OrganizationRepository_ReadBySlug_Call) RunAndReturn(run func(slug string) (models.Org, error)) *OrganizationRepository_ReadBySlug_Call

+ type OrganizationRepository_Read_Call struct

+ func (_c *OrganizationRepository_Read_Call) Return(org models.Org, err error) *OrganizationRepository_Read_Call

+ func (_c *OrganizationRepository_Read_Call) Run(run func(id uuid.UUID)) *OrganizationRepository_Read_Call

+ func (_c *OrganizationRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.Org, error)) *OrganizationRepository_Read_Call

+ type OrganizationRepository_SaveBatch_Call struct

+ func (_c *OrganizationRepository_SaveBatch_Call) Return(err error) *OrganizationRepository_SaveBatch_Call

+ func (_c *OrganizationRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.Org)) *OrganizationRepository_SaveBatch_Call

+ func (_c *OrganizationRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Org) error) *OrganizationRepository_SaveBatch_Call

+ type OrganizationRepository_Save_Call struct

+ func (_c *OrganizationRepository_Save_Call) Return(err error) *OrganizationRepository_Save_Call

+ func (_c *OrganizationRepository_Save_Call) Run(run func(tx core.DB, t *models.Org)) *OrganizationRepository_Save_Call

+ func (_c *OrganizationRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.Org) error) *OrganizationRepository_Save_Call

+ type OrganizationRepository_Transaction_Call struct

+ func (_c *OrganizationRepository_Transaction_Call) Return(err error) *OrganizationRepository_Transaction_Call

+ func (_c *OrganizationRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *OrganizationRepository_Transaction_Call

+ func (_c *OrganizationRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *OrganizationRepository_Transaction_Call

+ type OrganizationRepository_Update_Call struct

+ func (_c *OrganizationRepository_Update_Call) Return(err error) *OrganizationRepository_Update_Call

+ func (_c *OrganizationRepository_Update_Call) Run(run func(tx core.DB, organization *models.Org)) *OrganizationRepository_Update_Call

+ func (_c *OrganizationRepository_Update_Call) RunAndReturn(run func(tx core.DB, organization *models.Org) error) *OrganizationRepository_Update_Call

+ type OrganizationRepository_Upsert_Call struct

+ func (_c *OrganizationRepository_Upsert_Call) Return(err error) *OrganizationRepository_Upsert_Call

+ func (_c *OrganizationRepository_Upsert_Call) Run(...) *OrganizationRepository_Upsert_Call

+ func (_c *OrganizationRepository_Upsert_Call) RunAndReturn(...) *OrganizationRepository_Upsert_Call

+ type PersonalAccessTokenRepository struct

+ func NewPersonalAccessTokenRepository(t interface{ ... }) *PersonalAccessTokenRepository

+ func (_m *PersonalAccessTokenRepository) EXPECT() *PersonalAccessTokenRepository_Expecter

+ func (_mock *PersonalAccessTokenRepository) Activate(tx core.DB, id uuid.UUID) error

+ func (_mock *PersonalAccessTokenRepository) All() ([]models.PAT, error)

+ func (_mock *PersonalAccessTokenRepository) Begin() core.DB

+ func (_mock *PersonalAccessTokenRepository) Create(tx core.DB, t *models.PAT) error

+ func (_mock *PersonalAccessTokenRepository) CreateBatch(tx core.DB, ts []models.PAT) error

+ func (_mock *PersonalAccessTokenRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *PersonalAccessTokenRepository) DeleteBatch(tx core.DB, ids []models.PAT) error

+ func (_mock *PersonalAccessTokenRepository) DeleteByFingerprint(fingerprint string) error

+ func (_mock *PersonalAccessTokenRepository) FindByUserIDs(userID []uuid.UUID) ([]models.PAT, error)

+ func (_mock *PersonalAccessTokenRepository) GetByFingerprint(fingerprint string) (models.PAT, error)

+ func (_mock *PersonalAccessTokenRepository) GetDB(tx core.DB) core.DB

+ func (_mock *PersonalAccessTokenRepository) List(ids []uuid.UUID) ([]models.PAT, error)

+ func (_mock *PersonalAccessTokenRepository) ListByUserID(userID string) ([]models.PAT, error)

+ func (_mock *PersonalAccessTokenRepository) MarkAsLastUsedNow(fingerprint string) error

+ func (_mock *PersonalAccessTokenRepository) Read(id uuid.UUID) (models.PAT, error)

+ func (_mock *PersonalAccessTokenRepository) Save(tx core.DB, t *models.PAT) error

+ func (_mock *PersonalAccessTokenRepository) SaveBatch(tx core.DB, ts []models.PAT) error

+ func (_mock *PersonalAccessTokenRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *PersonalAccessTokenRepository) Upsert(t *[]*models.PAT, conflictingColumns []clause.Column, updateOnly []string) error

+ type PersonalAccessTokenRepository_Activate_Call struct

+ func (_c *PersonalAccessTokenRepository_Activate_Call) Return(err error) *PersonalAccessTokenRepository_Activate_Call

+ func (_c *PersonalAccessTokenRepository_Activate_Call) Run(run func(tx core.DB, id uuid.UUID)) *PersonalAccessTokenRepository_Activate_Call

+ func (_c *PersonalAccessTokenRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *PersonalAccessTokenRepository_Activate_Call

+ type PersonalAccessTokenRepository_All_Call struct

+ func (_c *PersonalAccessTokenRepository_All_Call) Return(pATs []models.PAT, err error) *PersonalAccessTokenRepository_All_Call

+ func (_c *PersonalAccessTokenRepository_All_Call) Run(run func()) *PersonalAccessTokenRepository_All_Call

+ func (_c *PersonalAccessTokenRepository_All_Call) RunAndReturn(run func() ([]models.PAT, error)) *PersonalAccessTokenRepository_All_Call

+ type PersonalAccessTokenRepository_Begin_Call struct

+ func (_c *PersonalAccessTokenRepository_Begin_Call) Return(v core.DB) *PersonalAccessTokenRepository_Begin_Call

+ func (_c *PersonalAccessTokenRepository_Begin_Call) Run(run func()) *PersonalAccessTokenRepository_Begin_Call

+ func (_c *PersonalAccessTokenRepository_Begin_Call) RunAndReturn(run func() core.DB) *PersonalAccessTokenRepository_Begin_Call

+ type PersonalAccessTokenRepository_CreateBatch_Call struct

+ func (_c *PersonalAccessTokenRepository_CreateBatch_Call) Return(err error) *PersonalAccessTokenRepository_CreateBatch_Call

+ func (_c *PersonalAccessTokenRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.PAT)) *PersonalAccessTokenRepository_CreateBatch_Call

+ func (_c *PersonalAccessTokenRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.PAT) error) *PersonalAccessTokenRepository_CreateBatch_Call

+ type PersonalAccessTokenRepository_Create_Call struct

+ func (_c *PersonalAccessTokenRepository_Create_Call) Return(err error) *PersonalAccessTokenRepository_Create_Call

+ func (_c *PersonalAccessTokenRepository_Create_Call) Run(run func(tx core.DB, t *models.PAT)) *PersonalAccessTokenRepository_Create_Call

+ func (_c *PersonalAccessTokenRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.PAT) error) *PersonalAccessTokenRepository_Create_Call

+ type PersonalAccessTokenRepository_DeleteBatch_Call struct

+ func (_c *PersonalAccessTokenRepository_DeleteBatch_Call) Return(err error) *PersonalAccessTokenRepository_DeleteBatch_Call

+ func (_c *PersonalAccessTokenRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.PAT)) *PersonalAccessTokenRepository_DeleteBatch_Call

+ func (_c *PersonalAccessTokenRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.PAT) error) *PersonalAccessTokenRepository_DeleteBatch_Call

+ type PersonalAccessTokenRepository_DeleteByFingerprint_Call struct

+ func (_c *PersonalAccessTokenRepository_DeleteByFingerprint_Call) Return(err error) *PersonalAccessTokenRepository_DeleteByFingerprint_Call

+ func (_c *PersonalAccessTokenRepository_DeleteByFingerprint_Call) Run(run func(fingerprint string)) *PersonalAccessTokenRepository_DeleteByFingerprint_Call

+ func (_c *PersonalAccessTokenRepository_DeleteByFingerprint_Call) RunAndReturn(run func(fingerprint string) error) *PersonalAccessTokenRepository_DeleteByFingerprint_Call

+ type PersonalAccessTokenRepository_Delete_Call struct

+ func (_c *PersonalAccessTokenRepository_Delete_Call) Return(err error) *PersonalAccessTokenRepository_Delete_Call

+ func (_c *PersonalAccessTokenRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *PersonalAccessTokenRepository_Delete_Call

+ func (_c *PersonalAccessTokenRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *PersonalAccessTokenRepository_Delete_Call

+ type PersonalAccessTokenRepository_Expecter struct

+ func (_e *PersonalAccessTokenRepository_Expecter) Activate(tx interface{}, id interface{}) *PersonalAccessTokenRepository_Activate_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) All() *PersonalAccessTokenRepository_All_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) Begin() *PersonalAccessTokenRepository_Begin_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) Create(tx interface{}, t interface{}) *PersonalAccessTokenRepository_Create_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *PersonalAccessTokenRepository_CreateBatch_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) Delete(tx interface{}, id interface{}) *PersonalAccessTokenRepository_Delete_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *PersonalAccessTokenRepository_DeleteBatch_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) DeleteByFingerprint(fingerprint interface{}) *PersonalAccessTokenRepository_DeleteByFingerprint_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) FindByUserIDs(userID interface{}) *PersonalAccessTokenRepository_FindByUserIDs_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) GetByFingerprint(fingerprint interface{}) *PersonalAccessTokenRepository_GetByFingerprint_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) GetDB(tx interface{}) *PersonalAccessTokenRepository_GetDB_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) List(ids interface{}) *PersonalAccessTokenRepository_List_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) ListByUserID(userID interface{}) *PersonalAccessTokenRepository_ListByUserID_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) MarkAsLastUsedNow(fingerprint interface{}) *PersonalAccessTokenRepository_MarkAsLastUsedNow_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) Read(id interface{}) *PersonalAccessTokenRepository_Read_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) Save(tx interface{}, t interface{}) *PersonalAccessTokenRepository_Save_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *PersonalAccessTokenRepository_SaveBatch_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) Transaction(fn interface{}) *PersonalAccessTokenRepository_Transaction_Call

+ func (_e *PersonalAccessTokenRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *PersonalAccessTokenRepository_Upsert_Call

+ type PersonalAccessTokenRepository_FindByUserIDs_Call struct

+ func (_c *PersonalAccessTokenRepository_FindByUserIDs_Call) Return(pATs []models.PAT, err error) *PersonalAccessTokenRepository_FindByUserIDs_Call

+ func (_c *PersonalAccessTokenRepository_FindByUserIDs_Call) Run(run func(userID []uuid.UUID)) *PersonalAccessTokenRepository_FindByUserIDs_Call

+ func (_c *PersonalAccessTokenRepository_FindByUserIDs_Call) RunAndReturn(run func(userID []uuid.UUID) ([]models.PAT, error)) *PersonalAccessTokenRepository_FindByUserIDs_Call

+ type PersonalAccessTokenRepository_GetByFingerprint_Call struct

+ func (_c *PersonalAccessTokenRepository_GetByFingerprint_Call) Return(pAT models.PAT, err error) *PersonalAccessTokenRepository_GetByFingerprint_Call

+ func (_c *PersonalAccessTokenRepository_GetByFingerprint_Call) Run(run func(fingerprint string)) *PersonalAccessTokenRepository_GetByFingerprint_Call

+ func (_c *PersonalAccessTokenRepository_GetByFingerprint_Call) RunAndReturn(run func(fingerprint string) (models.PAT, error)) *PersonalAccessTokenRepository_GetByFingerprint_Call

+ type PersonalAccessTokenRepository_GetDB_Call struct

+ func (_c *PersonalAccessTokenRepository_GetDB_Call) Return(v core.DB) *PersonalAccessTokenRepository_GetDB_Call

+ func (_c *PersonalAccessTokenRepository_GetDB_Call) Run(run func(tx core.DB)) *PersonalAccessTokenRepository_GetDB_Call

+ func (_c *PersonalAccessTokenRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *PersonalAccessTokenRepository_GetDB_Call

+ type PersonalAccessTokenRepository_ListByUserID_Call struct

+ func (_c *PersonalAccessTokenRepository_ListByUserID_Call) Return(pATs []models.PAT, err error) *PersonalAccessTokenRepository_ListByUserID_Call

+ func (_c *PersonalAccessTokenRepository_ListByUserID_Call) Run(run func(userID string)) *PersonalAccessTokenRepository_ListByUserID_Call

+ func (_c *PersonalAccessTokenRepository_ListByUserID_Call) RunAndReturn(run func(userID string) ([]models.PAT, error)) *PersonalAccessTokenRepository_ListByUserID_Call

+ type PersonalAccessTokenRepository_List_Call struct

+ func (_c *PersonalAccessTokenRepository_List_Call) Return(pATs []models.PAT, err error) *PersonalAccessTokenRepository_List_Call

+ func (_c *PersonalAccessTokenRepository_List_Call) Run(run func(ids []uuid.UUID)) *PersonalAccessTokenRepository_List_Call

+ func (_c *PersonalAccessTokenRepository_List_Call) RunAndReturn(run func(ids []uuid.UUID) ([]models.PAT, error)) *PersonalAccessTokenRepository_List_Call

+ type PersonalAccessTokenRepository_MarkAsLastUsedNow_Call struct

+ func (_c *PersonalAccessTokenRepository_MarkAsLastUsedNow_Call) Return(err error) *PersonalAccessTokenRepository_MarkAsLastUsedNow_Call

+ func (_c *PersonalAccessTokenRepository_MarkAsLastUsedNow_Call) Run(run func(fingerprint string)) *PersonalAccessTokenRepository_MarkAsLastUsedNow_Call

+ func (_c *PersonalAccessTokenRepository_MarkAsLastUsedNow_Call) RunAndReturn(run func(fingerprint string) error) *PersonalAccessTokenRepository_MarkAsLastUsedNow_Call

+ type PersonalAccessTokenRepository_Read_Call struct

+ func (_c *PersonalAccessTokenRepository_Read_Call) Return(pAT models.PAT, err error) *PersonalAccessTokenRepository_Read_Call

+ func (_c *PersonalAccessTokenRepository_Read_Call) Run(run func(id uuid.UUID)) *PersonalAccessTokenRepository_Read_Call

+ func (_c *PersonalAccessTokenRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.PAT, error)) *PersonalAccessTokenRepository_Read_Call

+ type PersonalAccessTokenRepository_SaveBatch_Call struct

+ func (_c *PersonalAccessTokenRepository_SaveBatch_Call) Return(err error) *PersonalAccessTokenRepository_SaveBatch_Call

+ func (_c *PersonalAccessTokenRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.PAT)) *PersonalAccessTokenRepository_SaveBatch_Call

+ func (_c *PersonalAccessTokenRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.PAT) error) *PersonalAccessTokenRepository_SaveBatch_Call

+ type PersonalAccessTokenRepository_Save_Call struct

+ func (_c *PersonalAccessTokenRepository_Save_Call) Return(err error) *PersonalAccessTokenRepository_Save_Call

+ func (_c *PersonalAccessTokenRepository_Save_Call) Run(run func(tx core.DB, t *models.PAT)) *PersonalAccessTokenRepository_Save_Call

+ func (_c *PersonalAccessTokenRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.PAT) error) *PersonalAccessTokenRepository_Save_Call

+ type PersonalAccessTokenRepository_Transaction_Call struct

+ func (_c *PersonalAccessTokenRepository_Transaction_Call) Return(err error) *PersonalAccessTokenRepository_Transaction_Call

+ func (_c *PersonalAccessTokenRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *PersonalAccessTokenRepository_Transaction_Call

+ func (_c *PersonalAccessTokenRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *PersonalAccessTokenRepository_Transaction_Call

+ type PersonalAccessTokenRepository_Upsert_Call struct

+ func (_c *PersonalAccessTokenRepository_Upsert_Call) Return(err error) *PersonalAccessTokenRepository_Upsert_Call

+ func (_c *PersonalAccessTokenRepository_Upsert_Call) Run(...) *PersonalAccessTokenRepository_Upsert_Call

+ func (_c *PersonalAccessTokenRepository_Upsert_Call) RunAndReturn(...) *PersonalAccessTokenRepository_Upsert_Call

+ type PolicyRepository struct

+ func NewPolicyRepository(t interface{ ... }) *PolicyRepository

+ func (_m *PolicyRepository) EXPECT() *PolicyRepository_Expecter

+ func (_mock *PolicyRepository) Activate(tx core.DB, id uuid.UUID) error

+ func (_mock *PolicyRepository) All() ([]models.Policy, error)

+ func (_mock *PolicyRepository) Begin() core.DB

+ func (_mock *PolicyRepository) Create(tx core.DB, t *models.Policy) error

+ func (_mock *PolicyRepository) CreateBatch(tx core.DB, ts []models.Policy) error

+ func (_mock *PolicyRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *PolicyRepository) DeleteBatch(tx core.DB, ids []models.Policy) error

+ func (_mock *PolicyRepository) FindByOrganizationID(organizationID uuid.UUID) ([]models.Policy, error)

+ func (_mock *PolicyRepository) FindByProjectID(projectID uuid.UUID) ([]models.Policy, error)

+ func (_mock *PolicyRepository) FindCommunityManagedPolicies() ([]models.Policy, error)

+ func (_mock *PolicyRepository) GetDB(tx core.DB) core.DB

+ func (_mock *PolicyRepository) List(ids []uuid.UUID) ([]models.Policy, error)

+ func (_mock *PolicyRepository) Read(id uuid.UUID) (models.Policy, error)

+ func (_mock *PolicyRepository) Save(tx core.DB, t *models.Policy) error

+ func (_mock *PolicyRepository) SaveBatch(tx core.DB, ts []models.Policy) error

+ func (_mock *PolicyRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *PolicyRepository) Upsert(t *[]*models.Policy, conflictingColumns []clause.Column, updateOnly []string) error

+ type PolicyRepository_Activate_Call struct

+ func (_c *PolicyRepository_Activate_Call) Return(err error) *PolicyRepository_Activate_Call

+ func (_c *PolicyRepository_Activate_Call) Run(run func(tx core.DB, id uuid.UUID)) *PolicyRepository_Activate_Call

+ func (_c *PolicyRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *PolicyRepository_Activate_Call

+ type PolicyRepository_All_Call struct

+ func (_c *PolicyRepository_All_Call) Return(policys []models.Policy, err error) *PolicyRepository_All_Call

+ func (_c *PolicyRepository_All_Call) Run(run func()) *PolicyRepository_All_Call

+ func (_c *PolicyRepository_All_Call) RunAndReturn(run func() ([]models.Policy, error)) *PolicyRepository_All_Call

+ type PolicyRepository_Begin_Call struct

+ func (_c *PolicyRepository_Begin_Call) Return(v core.DB) *PolicyRepository_Begin_Call

+ func (_c *PolicyRepository_Begin_Call) Run(run func()) *PolicyRepository_Begin_Call

+ func (_c *PolicyRepository_Begin_Call) RunAndReturn(run func() core.DB) *PolicyRepository_Begin_Call

+ type PolicyRepository_CreateBatch_Call struct

+ func (_c *PolicyRepository_CreateBatch_Call) Return(err error) *PolicyRepository_CreateBatch_Call

+ func (_c *PolicyRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.Policy)) *PolicyRepository_CreateBatch_Call

+ func (_c *PolicyRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Policy) error) *PolicyRepository_CreateBatch_Call

+ type PolicyRepository_Create_Call struct

+ func (_c *PolicyRepository_Create_Call) Return(err error) *PolicyRepository_Create_Call

+ func (_c *PolicyRepository_Create_Call) Run(run func(tx core.DB, t *models.Policy)) *PolicyRepository_Create_Call

+ func (_c *PolicyRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.Policy) error) *PolicyRepository_Create_Call

+ type PolicyRepository_DeleteBatch_Call struct

+ func (_c *PolicyRepository_DeleteBatch_Call) Return(err error) *PolicyRepository_DeleteBatch_Call

+ func (_c *PolicyRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.Policy)) *PolicyRepository_DeleteBatch_Call

+ func (_c *PolicyRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.Policy) error) *PolicyRepository_DeleteBatch_Call

+ type PolicyRepository_Delete_Call struct

+ func (_c *PolicyRepository_Delete_Call) Return(err error) *PolicyRepository_Delete_Call

+ func (_c *PolicyRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *PolicyRepository_Delete_Call

+ func (_c *PolicyRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *PolicyRepository_Delete_Call

+ type PolicyRepository_Expecter struct

+ func (_e *PolicyRepository_Expecter) Activate(tx interface{}, id interface{}) *PolicyRepository_Activate_Call

+ func (_e *PolicyRepository_Expecter) All() *PolicyRepository_All_Call

+ func (_e *PolicyRepository_Expecter) Begin() *PolicyRepository_Begin_Call

+ func (_e *PolicyRepository_Expecter) Create(tx interface{}, t interface{}) *PolicyRepository_Create_Call

+ func (_e *PolicyRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *PolicyRepository_CreateBatch_Call

+ func (_e *PolicyRepository_Expecter) Delete(tx interface{}, id interface{}) *PolicyRepository_Delete_Call

+ func (_e *PolicyRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *PolicyRepository_DeleteBatch_Call

+ func (_e *PolicyRepository_Expecter) FindByOrganizationID(organizationID interface{}) *PolicyRepository_FindByOrganizationID_Call

+ func (_e *PolicyRepository_Expecter) FindByProjectID(projectID interface{}) *PolicyRepository_FindByProjectID_Call

+ func (_e *PolicyRepository_Expecter) FindCommunityManagedPolicies() *PolicyRepository_FindCommunityManagedPolicies_Call

+ func (_e *PolicyRepository_Expecter) GetDB(tx interface{}) *PolicyRepository_GetDB_Call

+ func (_e *PolicyRepository_Expecter) List(ids interface{}) *PolicyRepository_List_Call

+ func (_e *PolicyRepository_Expecter) Read(id interface{}) *PolicyRepository_Read_Call

+ func (_e *PolicyRepository_Expecter) Save(tx interface{}, t interface{}) *PolicyRepository_Save_Call

+ func (_e *PolicyRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *PolicyRepository_SaveBatch_Call

+ func (_e *PolicyRepository_Expecter) Transaction(fn interface{}) *PolicyRepository_Transaction_Call

+ func (_e *PolicyRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *PolicyRepository_Upsert_Call

+ type PolicyRepository_FindByOrganizationID_Call struct

+ func (_c *PolicyRepository_FindByOrganizationID_Call) Return(policys []models.Policy, err error) *PolicyRepository_FindByOrganizationID_Call

+ func (_c *PolicyRepository_FindByOrganizationID_Call) Run(run func(organizationID uuid.UUID)) *PolicyRepository_FindByOrganizationID_Call

+ func (_c *PolicyRepository_FindByOrganizationID_Call) RunAndReturn(run func(organizationID uuid.UUID) ([]models.Policy, error)) *PolicyRepository_FindByOrganizationID_Call

+ type PolicyRepository_FindByProjectID_Call struct

+ func (_c *PolicyRepository_FindByProjectID_Call) Return(policys []models.Policy, err error) *PolicyRepository_FindByProjectID_Call

+ func (_c *PolicyRepository_FindByProjectID_Call) Run(run func(projectID uuid.UUID)) *PolicyRepository_FindByProjectID_Call

+ func (_c *PolicyRepository_FindByProjectID_Call) RunAndReturn(run func(projectID uuid.UUID) ([]models.Policy, error)) *PolicyRepository_FindByProjectID_Call

+ type PolicyRepository_FindCommunityManagedPolicies_Call struct

+ func (_c *PolicyRepository_FindCommunityManagedPolicies_Call) Return(policys []models.Policy, err error) *PolicyRepository_FindCommunityManagedPolicies_Call

+ func (_c *PolicyRepository_FindCommunityManagedPolicies_Call) Run(run func()) *PolicyRepository_FindCommunityManagedPolicies_Call

+ func (_c *PolicyRepository_FindCommunityManagedPolicies_Call) RunAndReturn(run func() ([]models.Policy, error)) *PolicyRepository_FindCommunityManagedPolicies_Call

+ type PolicyRepository_GetDB_Call struct

+ func (_c *PolicyRepository_GetDB_Call) Return(v core.DB) *PolicyRepository_GetDB_Call

+ func (_c *PolicyRepository_GetDB_Call) Run(run func(tx core.DB)) *PolicyRepository_GetDB_Call

+ func (_c *PolicyRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *PolicyRepository_GetDB_Call

+ type PolicyRepository_List_Call struct

+ func (_c *PolicyRepository_List_Call) Return(policys []models.Policy, err error) *PolicyRepository_List_Call

+ func (_c *PolicyRepository_List_Call) Run(run func(ids []uuid.UUID)) *PolicyRepository_List_Call

+ func (_c *PolicyRepository_List_Call) RunAndReturn(run func(ids []uuid.UUID) ([]models.Policy, error)) *PolicyRepository_List_Call

+ type PolicyRepository_Read_Call struct

+ func (_c *PolicyRepository_Read_Call) Return(policy models.Policy, err error) *PolicyRepository_Read_Call

+ func (_c *PolicyRepository_Read_Call) Run(run func(id uuid.UUID)) *PolicyRepository_Read_Call

+ func (_c *PolicyRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.Policy, error)) *PolicyRepository_Read_Call

+ type PolicyRepository_SaveBatch_Call struct

+ func (_c *PolicyRepository_SaveBatch_Call) Return(err error) *PolicyRepository_SaveBatch_Call

+ func (_c *PolicyRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.Policy)) *PolicyRepository_SaveBatch_Call

+ func (_c *PolicyRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Policy) error) *PolicyRepository_SaveBatch_Call

+ type PolicyRepository_Save_Call struct

+ func (_c *PolicyRepository_Save_Call) Return(err error) *PolicyRepository_Save_Call

+ func (_c *PolicyRepository_Save_Call) Run(run func(tx core.DB, t *models.Policy)) *PolicyRepository_Save_Call

+ func (_c *PolicyRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.Policy) error) *PolicyRepository_Save_Call

+ type PolicyRepository_Transaction_Call struct

+ func (_c *PolicyRepository_Transaction_Call) Return(err error) *PolicyRepository_Transaction_Call

+ func (_c *PolicyRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *PolicyRepository_Transaction_Call

+ func (_c *PolicyRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *PolicyRepository_Transaction_Call

+ type PolicyRepository_Upsert_Call struct

+ func (_c *PolicyRepository_Upsert_Call) Return(err error) *PolicyRepository_Upsert_Call

+ func (_c *PolicyRepository_Upsert_Call) Run(...) *PolicyRepository_Upsert_Call

+ func (_c *PolicyRepository_Upsert_Call) RunAndReturn(...) *PolicyRepository_Upsert_Call

+ type ProjectRepository struct

+ func NewProjectRepository(t interface{ ... }) *ProjectRepository

+ func (_m *ProjectRepository) EXPECT() *ProjectRepository_Expecter

+ func (_mock *ProjectRepository) Activate(tx core.DB, projectID uuid.UUID) error

+ func (_mock *ProjectRepository) Create(tx core.DB, project *models.Project) error

+ func (_mock *ProjectRepository) Delete(tx core.DB, projectID uuid.UUID) error

+ func (_mock *ProjectRepository) DisablePolicyForProject(tx core.DB, projectID uuid.UUID, policyID uuid.UUID) error

+ func (_mock *ProjectRepository) EnableCommunityManagedPolicies(tx core.DB, projectID uuid.UUID) error

+ func (_mock *ProjectRepository) EnablePolicyForProject(tx core.DB, projectID uuid.UUID, policyID uuid.UUID) error

+ func (_mock *ProjectRepository) GetByOrgID(organizationID uuid.UUID) ([]models.Project, error)

+ func (_mock *ProjectRepository) GetDirectChildProjects(projectID uuid.UUID) ([]models.Project, error)

+ func (_mock *ProjectRepository) GetProjectByAssetID(assetID uuid.UUID) (models.Project, error)

+ func (_mock *ProjectRepository) List(idSlice []uuid.UUID, parentID *uuid.UUID, organizationID uuid.UUID) ([]models.Project, error)

+ func (_mock *ProjectRepository) ListPaged(projectIDs []uuid.UUID, parentID *uuid.UUID, orgID uuid.UUID, ...) (core.Paged[models.Project], error)

+ func (_mock *ProjectRepository) Read(projectID uuid.UUID) (models.Project, error)

+ func (_mock *ProjectRepository) ReadBySlug(organizationID uuid.UUID, slug string) (models.Project, error)

+ func (_mock *ProjectRepository) ReadBySlugUnscoped(organizationID uuid.UUID, slug string) (models.Project, error)

+ func (_mock *ProjectRepository) RecursivelyGetChildProjects(projectID uuid.UUID) ([]models.Project, error)

+ func (_mock *ProjectRepository) Update(tx core.DB, project *models.Project) error

+ func (_mock *ProjectRepository) Upsert(projects *[]*models.Project, conflictingColumns []clause.Column, ...) error

+ func (_mock *ProjectRepository) UpsertSplit(tx core.DB, externalProviderID string, projects []*models.Project) ([]*models.Project, []*models.Project, error)

+ type ProjectRepository_Activate_Call struct

+ func (_c *ProjectRepository_Activate_Call) Return(err error) *ProjectRepository_Activate_Call

+ func (_c *ProjectRepository_Activate_Call) Run(run func(tx core.DB, projectID uuid.UUID)) *ProjectRepository_Activate_Call

+ func (_c *ProjectRepository_Activate_Call) RunAndReturn(run func(tx core.DB, projectID uuid.UUID) error) *ProjectRepository_Activate_Call

+ type ProjectRepository_Create_Call struct

+ func (_c *ProjectRepository_Create_Call) Return(err error) *ProjectRepository_Create_Call

+ func (_c *ProjectRepository_Create_Call) Run(run func(tx core.DB, project *models.Project)) *ProjectRepository_Create_Call

+ func (_c *ProjectRepository_Create_Call) RunAndReturn(run func(tx core.DB, project *models.Project) error) *ProjectRepository_Create_Call

+ type ProjectRepository_Delete_Call struct

+ func (_c *ProjectRepository_Delete_Call) Return(err error) *ProjectRepository_Delete_Call

+ func (_c *ProjectRepository_Delete_Call) Run(run func(tx core.DB, projectID uuid.UUID)) *ProjectRepository_Delete_Call

+ func (_c *ProjectRepository_Delete_Call) RunAndReturn(run func(tx core.DB, projectID uuid.UUID) error) *ProjectRepository_Delete_Call

+ type ProjectRepository_DisablePolicyForProject_Call struct

+ func (_c *ProjectRepository_DisablePolicyForProject_Call) Return(err error) *ProjectRepository_DisablePolicyForProject_Call

+ func (_c *ProjectRepository_DisablePolicyForProject_Call) Run(run func(tx core.DB, projectID uuid.UUID, policyID uuid.UUID)) *ProjectRepository_DisablePolicyForProject_Call

+ func (_c *ProjectRepository_DisablePolicyForProject_Call) RunAndReturn(run func(tx core.DB, projectID uuid.UUID, policyID uuid.UUID) error) *ProjectRepository_DisablePolicyForProject_Call

+ type ProjectRepository_EnableCommunityManagedPolicies_Call struct

+ func (_c *ProjectRepository_EnableCommunityManagedPolicies_Call) Return(err error) *ProjectRepository_EnableCommunityManagedPolicies_Call

+ func (_c *ProjectRepository_EnableCommunityManagedPolicies_Call) Run(run func(tx core.DB, projectID uuid.UUID)) *ProjectRepository_EnableCommunityManagedPolicies_Call

+ func (_c *ProjectRepository_EnableCommunityManagedPolicies_Call) RunAndReturn(run func(tx core.DB, projectID uuid.UUID) error) *ProjectRepository_EnableCommunityManagedPolicies_Call

+ type ProjectRepository_EnablePolicyForProject_Call struct

+ func (_c *ProjectRepository_EnablePolicyForProject_Call) Return(err error) *ProjectRepository_EnablePolicyForProject_Call

+ func (_c *ProjectRepository_EnablePolicyForProject_Call) Run(run func(tx core.DB, projectID uuid.UUID, policyID uuid.UUID)) *ProjectRepository_EnablePolicyForProject_Call

+ func (_c *ProjectRepository_EnablePolicyForProject_Call) RunAndReturn(run func(tx core.DB, projectID uuid.UUID, policyID uuid.UUID) error) *ProjectRepository_EnablePolicyForProject_Call

+ type ProjectRepository_Expecter struct

+ func (_e *ProjectRepository_Expecter) Activate(tx interface{}, projectID interface{}) *ProjectRepository_Activate_Call

+ func (_e *ProjectRepository_Expecter) Create(tx interface{}, project interface{}) *ProjectRepository_Create_Call

+ func (_e *ProjectRepository_Expecter) Delete(tx interface{}, projectID interface{}) *ProjectRepository_Delete_Call

+ func (_e *ProjectRepository_Expecter) DisablePolicyForProject(tx interface{}, projectID interface{}, policyID interface{}) *ProjectRepository_DisablePolicyForProject_Call

+ func (_e *ProjectRepository_Expecter) EnableCommunityManagedPolicies(tx interface{}, projectID interface{}) *ProjectRepository_EnableCommunityManagedPolicies_Call

+ func (_e *ProjectRepository_Expecter) EnablePolicyForProject(tx interface{}, projectID interface{}, policyID interface{}) *ProjectRepository_EnablePolicyForProject_Call

+ func (_e *ProjectRepository_Expecter) GetByOrgID(organizationID interface{}) *ProjectRepository_GetByOrgID_Call

+ func (_e *ProjectRepository_Expecter) GetDirectChildProjects(projectID interface{}) *ProjectRepository_GetDirectChildProjects_Call

+ func (_e *ProjectRepository_Expecter) GetProjectByAssetID(assetID interface{}) *ProjectRepository_GetProjectByAssetID_Call

+ func (_e *ProjectRepository_Expecter) List(idSlice interface{}, parentID interface{}, organizationID interface{}) *ProjectRepository_List_Call

+ func (_e *ProjectRepository_Expecter) ListPaged(projectIDs interface{}, parentID interface{}, orgID interface{}, ...) *ProjectRepository_ListPaged_Call

+ func (_e *ProjectRepository_Expecter) Read(projectID interface{}) *ProjectRepository_Read_Call

+ func (_e *ProjectRepository_Expecter) ReadBySlug(organizationID interface{}, slug interface{}) *ProjectRepository_ReadBySlug_Call

+ func (_e *ProjectRepository_Expecter) ReadBySlugUnscoped(organizationID interface{}, slug interface{}) *ProjectRepository_ReadBySlugUnscoped_Call

+ func (_e *ProjectRepository_Expecter) RecursivelyGetChildProjects(projectID interface{}) *ProjectRepository_RecursivelyGetChildProjects_Call

+ func (_e *ProjectRepository_Expecter) Update(tx interface{}, project interface{}) *ProjectRepository_Update_Call

+ func (_e *ProjectRepository_Expecter) Upsert(projects interface{}, conflictingColumns interface{}, toUpdate interface{}) *ProjectRepository_Upsert_Call

+ func (_e *ProjectRepository_Expecter) UpsertSplit(tx interface{}, externalProviderID interface{}, projects interface{}) *ProjectRepository_UpsertSplit_Call

+ type ProjectRepository_GetByOrgID_Call struct

+ func (_c *ProjectRepository_GetByOrgID_Call) Return(projects []models.Project, err error) *ProjectRepository_GetByOrgID_Call

+ func (_c *ProjectRepository_GetByOrgID_Call) Run(run func(organizationID uuid.UUID)) *ProjectRepository_GetByOrgID_Call

+ func (_c *ProjectRepository_GetByOrgID_Call) RunAndReturn(run func(organizationID uuid.UUID) ([]models.Project, error)) *ProjectRepository_GetByOrgID_Call

+ type ProjectRepository_GetDirectChildProjects_Call struct

+ func (_c *ProjectRepository_GetDirectChildProjects_Call) Return(projects []models.Project, err error) *ProjectRepository_GetDirectChildProjects_Call

+ func (_c *ProjectRepository_GetDirectChildProjects_Call) Run(run func(projectID uuid.UUID)) *ProjectRepository_GetDirectChildProjects_Call

+ func (_c *ProjectRepository_GetDirectChildProjects_Call) RunAndReturn(run func(projectID uuid.UUID) ([]models.Project, error)) *ProjectRepository_GetDirectChildProjects_Call

+ type ProjectRepository_GetProjectByAssetID_Call struct

+ func (_c *ProjectRepository_GetProjectByAssetID_Call) Return(project models.Project, err error) *ProjectRepository_GetProjectByAssetID_Call

+ func (_c *ProjectRepository_GetProjectByAssetID_Call) Run(run func(assetID uuid.UUID)) *ProjectRepository_GetProjectByAssetID_Call

+ func (_c *ProjectRepository_GetProjectByAssetID_Call) RunAndReturn(run func(assetID uuid.UUID) (models.Project, error)) *ProjectRepository_GetProjectByAssetID_Call

+ type ProjectRepository_ListPaged_Call struct

+ func (_c *ProjectRepository_ListPaged_Call) Return(paged core.Paged[models.Project], err error) *ProjectRepository_ListPaged_Call

+ func (_c *ProjectRepository_ListPaged_Call) Run(run func(projectIDs []uuid.UUID, parentID *uuid.UUID, orgID uuid.UUID, ...)) *ProjectRepository_ListPaged_Call

+ func (_c *ProjectRepository_ListPaged_Call) RunAndReturn(...) *ProjectRepository_ListPaged_Call

+ type ProjectRepository_List_Call struct

+ func (_c *ProjectRepository_List_Call) Return(projects []models.Project, err error) *ProjectRepository_List_Call

+ func (_c *ProjectRepository_List_Call) Run(run func(idSlice []uuid.UUID, parentID *uuid.UUID, organizationID uuid.UUID)) *ProjectRepository_List_Call

+ func (_c *ProjectRepository_List_Call) RunAndReturn(...) *ProjectRepository_List_Call

+ type ProjectRepository_ReadBySlugUnscoped_Call struct

+ func (_c *ProjectRepository_ReadBySlugUnscoped_Call) Return(project models.Project, err error) *ProjectRepository_ReadBySlugUnscoped_Call

+ func (_c *ProjectRepository_ReadBySlugUnscoped_Call) Run(run func(organizationID uuid.UUID, slug string)) *ProjectRepository_ReadBySlugUnscoped_Call

+ func (_c *ProjectRepository_ReadBySlugUnscoped_Call) RunAndReturn(run func(organizationID uuid.UUID, slug string) (models.Project, error)) *ProjectRepository_ReadBySlugUnscoped_Call

+ type ProjectRepository_ReadBySlug_Call struct

+ func (_c *ProjectRepository_ReadBySlug_Call) Return(project models.Project, err error) *ProjectRepository_ReadBySlug_Call

+ func (_c *ProjectRepository_ReadBySlug_Call) Run(run func(organizationID uuid.UUID, slug string)) *ProjectRepository_ReadBySlug_Call

+ func (_c *ProjectRepository_ReadBySlug_Call) RunAndReturn(run func(organizationID uuid.UUID, slug string) (models.Project, error)) *ProjectRepository_ReadBySlug_Call

+ type ProjectRepository_Read_Call struct

+ func (_c *ProjectRepository_Read_Call) Return(project models.Project, err error) *ProjectRepository_Read_Call

+ func (_c *ProjectRepository_Read_Call) Run(run func(projectID uuid.UUID)) *ProjectRepository_Read_Call

+ func (_c *ProjectRepository_Read_Call) RunAndReturn(run func(projectID uuid.UUID) (models.Project, error)) *ProjectRepository_Read_Call

+ type ProjectRepository_RecursivelyGetChildProjects_Call struct

+ func (_c *ProjectRepository_RecursivelyGetChildProjects_Call) Return(projects []models.Project, err error) *ProjectRepository_RecursivelyGetChildProjects_Call

+ func (_c *ProjectRepository_RecursivelyGetChildProjects_Call) Run(run func(projectID uuid.UUID)) *ProjectRepository_RecursivelyGetChildProjects_Call

+ func (_c *ProjectRepository_RecursivelyGetChildProjects_Call) RunAndReturn(run func(projectID uuid.UUID) ([]models.Project, error)) *ProjectRepository_RecursivelyGetChildProjects_Call

+ type ProjectRepository_Update_Call struct

+ func (_c *ProjectRepository_Update_Call) Return(err error) *ProjectRepository_Update_Call

+ func (_c *ProjectRepository_Update_Call) Run(run func(tx core.DB, project *models.Project)) *ProjectRepository_Update_Call

+ func (_c *ProjectRepository_Update_Call) RunAndReturn(run func(tx core.DB, project *models.Project) error) *ProjectRepository_Update_Call

+ type ProjectRepository_UpsertSplit_Call struct

+ func (_c *ProjectRepository_UpsertSplit_Call) Return(projects1 []*models.Project, projects2 []*models.Project, err error) *ProjectRepository_UpsertSplit_Call

+ func (_c *ProjectRepository_UpsertSplit_Call) Run(run func(tx core.DB, externalProviderID string, projects []*models.Project)) *ProjectRepository_UpsertSplit_Call

+ func (_c *ProjectRepository_UpsertSplit_Call) RunAndReturn(...) *ProjectRepository_UpsertSplit_Call

+ type ProjectRepository_Upsert_Call struct

+ func (_c *ProjectRepository_Upsert_Call) Return(err error) *ProjectRepository_Upsert_Call

+ func (_c *ProjectRepository_Upsert_Call) Run(run func(projects *[]*models.Project, conflictingColumns []clause.Column, ...)) *ProjectRepository_Upsert_Call

+ func (_c *ProjectRepository_Upsert_Call) RunAndReturn(...) *ProjectRepository_Upsert_Call

+ type ProjectRiskHistoryRepository struct

+ func NewProjectRiskHistoryRepository(t interface{ ... }) *ProjectRiskHistoryRepository

+ func (_m *ProjectRiskHistoryRepository) EXPECT() *ProjectRiskHistoryRepository_Expecter

+ func (_mock *ProjectRiskHistoryRepository) GetRiskHistory(projectID uuid.UUID, start time.Time, end time.Time) ([]models.ProjectRiskHistory, error)

+ func (_mock *ProjectRiskHistoryRepository) UpdateRiskAggregation(projectRisk *models.ProjectRiskHistory) error

+ type ProjectRiskHistoryRepository_Expecter struct

+ func (_e *ProjectRiskHistoryRepository_Expecter) GetRiskHistory(projectID interface{}, start interface{}, end interface{}) *ProjectRiskHistoryRepository_GetRiskHistory_Call

+ func (_e *ProjectRiskHistoryRepository_Expecter) UpdateRiskAggregation(projectRisk interface{}) *ProjectRiskHistoryRepository_UpdateRiskAggregation_Call

+ type ProjectRiskHistoryRepository_GetRiskHistory_Call struct

+ func (_c *ProjectRiskHistoryRepository_GetRiskHistory_Call) Return(projectRiskHistorys []models.ProjectRiskHistory, err error) *ProjectRiskHistoryRepository_GetRiskHistory_Call

+ func (_c *ProjectRiskHistoryRepository_GetRiskHistory_Call) Run(run func(projectID uuid.UUID, start time.Time, end time.Time)) *ProjectRiskHistoryRepository_GetRiskHistory_Call

+ func (_c *ProjectRiskHistoryRepository_GetRiskHistory_Call) RunAndReturn(...) *ProjectRiskHistoryRepository_GetRiskHistory_Call

+ type ProjectRiskHistoryRepository_UpdateRiskAggregation_Call struct

+ func (_c *ProjectRiskHistoryRepository_UpdateRiskAggregation_Call) Return(err error) *ProjectRiskHistoryRepository_UpdateRiskAggregation_Call

+ func (_c *ProjectRiskHistoryRepository_UpdateRiskAggregation_Call) Run(run func(projectRisk *models.ProjectRiskHistory)) *ProjectRiskHistoryRepository_UpdateRiskAggregation_Call

+ func (_c *ProjectRiskHistoryRepository_UpdateRiskAggregation_Call) RunAndReturn(run func(projectRisk *models.ProjectRiskHistory) error) *ProjectRiskHistoryRepository_UpdateRiskAggregation_Call

+ type ProjectService struct

+ func NewProjectService(t interface{ ... }) *ProjectService

+ func (_m *ProjectService) EXPECT() *ProjectService_Expecter

+ func (_mock *ProjectService) BootstrapProject(rbac core.AccessControl, project *models.Project) error

+ func (_mock *ProjectService) CreateProject(ctx core.Context, project *models.Project) error

+ func (_mock *ProjectService) GetDirectChildProjects(projectID uuid.UUID) ([]models.Project, error)

+ func (_mock *ProjectService) ListAllowedProjects(ctx core.Context) ([]models.Project, error)

+ func (_mock *ProjectService) ListAllowedProjectsPaged(c core.Context) (core.Paged[models.Project], error)

+ func (_mock *ProjectService) ListProjectsByOrganizationID(organizationID uuid.UUID) ([]models.Project, error)

+ func (_mock *ProjectService) ReadBySlug(ctx core.Context, organizationID uuid.UUID, slug string) (models.Project, error)

+ func (_mock *ProjectService) RecursivelyGetChildProjects(projectID uuid.UUID) ([]models.Project, error)

+ type ProjectService_BootstrapProject_Call struct

+ func (_c *ProjectService_BootstrapProject_Call) Return(err error) *ProjectService_BootstrapProject_Call

+ func (_c *ProjectService_BootstrapProject_Call) Run(run func(rbac core.AccessControl, project *models.Project)) *ProjectService_BootstrapProject_Call

+ func (_c *ProjectService_BootstrapProject_Call) RunAndReturn(run func(rbac core.AccessControl, project *models.Project) error) *ProjectService_BootstrapProject_Call

+ type ProjectService_CreateProject_Call struct

+ func (_c *ProjectService_CreateProject_Call) Return(err error) *ProjectService_CreateProject_Call

+ func (_c *ProjectService_CreateProject_Call) Run(run func(ctx core.Context, project *models.Project)) *ProjectService_CreateProject_Call

+ func (_c *ProjectService_CreateProject_Call) RunAndReturn(run func(ctx core.Context, project *models.Project) error) *ProjectService_CreateProject_Call

+ type ProjectService_Expecter struct

+ func (_e *ProjectService_Expecter) BootstrapProject(rbac interface{}, project interface{}) *ProjectService_BootstrapProject_Call

+ func (_e *ProjectService_Expecter) CreateProject(ctx interface{}, project interface{}) *ProjectService_CreateProject_Call

+ func (_e *ProjectService_Expecter) GetDirectChildProjects(projectID interface{}) *ProjectService_GetDirectChildProjects_Call

+ func (_e *ProjectService_Expecter) ListAllowedProjects(ctx interface{}) *ProjectService_ListAllowedProjects_Call

+ func (_e *ProjectService_Expecter) ListAllowedProjectsPaged(c interface{}) *ProjectService_ListAllowedProjectsPaged_Call

+ func (_e *ProjectService_Expecter) ListProjectsByOrganizationID(organizationID interface{}) *ProjectService_ListProjectsByOrganizationID_Call

+ func (_e *ProjectService_Expecter) ReadBySlug(ctx interface{}, organizationID interface{}, slug interface{}) *ProjectService_ReadBySlug_Call

+ func (_e *ProjectService_Expecter) RecursivelyGetChildProjects(projectID interface{}) *ProjectService_RecursivelyGetChildProjects_Call

+ type ProjectService_GetDirectChildProjects_Call struct

+ func (_c *ProjectService_GetDirectChildProjects_Call) Return(projects []models.Project, err error) *ProjectService_GetDirectChildProjects_Call

+ func (_c *ProjectService_GetDirectChildProjects_Call) Run(run func(projectID uuid.UUID)) *ProjectService_GetDirectChildProjects_Call

+ func (_c *ProjectService_GetDirectChildProjects_Call) RunAndReturn(run func(projectID uuid.UUID) ([]models.Project, error)) *ProjectService_GetDirectChildProjects_Call

+ type ProjectService_ListAllowedProjectsPaged_Call struct

+ func (_c *ProjectService_ListAllowedProjectsPaged_Call) Return(paged core.Paged[models.Project], err error) *ProjectService_ListAllowedProjectsPaged_Call

+ func (_c *ProjectService_ListAllowedProjectsPaged_Call) Run(run func(c core.Context)) *ProjectService_ListAllowedProjectsPaged_Call

+ func (_c *ProjectService_ListAllowedProjectsPaged_Call) RunAndReturn(run func(c core.Context) (core.Paged[models.Project], error)) *ProjectService_ListAllowedProjectsPaged_Call

+ type ProjectService_ListAllowedProjects_Call struct

+ func (_c *ProjectService_ListAllowedProjects_Call) Return(projects []models.Project, err error) *ProjectService_ListAllowedProjects_Call

+ func (_c *ProjectService_ListAllowedProjects_Call) Run(run func(ctx core.Context)) *ProjectService_ListAllowedProjects_Call

+ func (_c *ProjectService_ListAllowedProjects_Call) RunAndReturn(run func(ctx core.Context) ([]models.Project, error)) *ProjectService_ListAllowedProjects_Call

+ type ProjectService_ListProjectsByOrganizationID_Call struct

+ func (_c *ProjectService_ListProjectsByOrganizationID_Call) Return(projects []models.Project, err error) *ProjectService_ListProjectsByOrganizationID_Call

+ func (_c *ProjectService_ListProjectsByOrganizationID_Call) Run(run func(organizationID uuid.UUID)) *ProjectService_ListProjectsByOrganizationID_Call

+ func (_c *ProjectService_ListProjectsByOrganizationID_Call) RunAndReturn(run func(organizationID uuid.UUID) ([]models.Project, error)) *ProjectService_ListProjectsByOrganizationID_Call

+ type ProjectService_ReadBySlug_Call struct

+ func (_c *ProjectService_ReadBySlug_Call) Return(project models.Project, err error) *ProjectService_ReadBySlug_Call

+ func (_c *ProjectService_ReadBySlug_Call) Run(run func(ctx core.Context, organizationID uuid.UUID, slug string)) *ProjectService_ReadBySlug_Call

+ func (_c *ProjectService_ReadBySlug_Call) RunAndReturn(...) *ProjectService_ReadBySlug_Call

+ type ProjectService_RecursivelyGetChildProjects_Call struct

+ func (_c *ProjectService_RecursivelyGetChildProjects_Call) Return(projects []models.Project, err error) *ProjectService_RecursivelyGetChildProjects_Call

+ func (_c *ProjectService_RecursivelyGetChildProjects_Call) Run(run func(projectID uuid.UUID)) *ProjectService_RecursivelyGetChildProjects_Call

+ func (_c *ProjectService_RecursivelyGetChildProjects_Call) RunAndReturn(run func(projectID uuid.UUID) ([]models.Project, error)) *ProjectService_RecursivelyGetChildProjects_Call

+ type RBACProvider struct

+ func NewRBACProvider(t interface{ ... }) *RBACProvider

+ func (_m *RBACProvider) EXPECT() *RBACProvider_Expecter

+ func (_mock *RBACProvider) DomainsOfUser(user string) ([]string, error)

+ func (_mock *RBACProvider) GetDomainRBAC(domain string) core.AccessControl

+ type RBACProvider_DomainsOfUser_Call struct

+ func (_c *RBACProvider_DomainsOfUser_Call) Return(strings []string, err error) *RBACProvider_DomainsOfUser_Call

+ func (_c *RBACProvider_DomainsOfUser_Call) Run(run func(user string)) *RBACProvider_DomainsOfUser_Call

+ func (_c *RBACProvider_DomainsOfUser_Call) RunAndReturn(run func(user string) ([]string, error)) *RBACProvider_DomainsOfUser_Call

+ type RBACProvider_Expecter struct

+ func (_e *RBACProvider_Expecter) DomainsOfUser(user interface{}) *RBACProvider_DomainsOfUser_Call

+ func (_e *RBACProvider_Expecter) GetDomainRBAC(domain interface{}) *RBACProvider_GetDomainRBAC_Call

+ type RBACProvider_GetDomainRBAC_Call struct

+ func (_c *RBACProvider_GetDomainRBAC_Call) Return(accessControl core.AccessControl) *RBACProvider_GetDomainRBAC_Call

+ func (_c *RBACProvider_GetDomainRBAC_Call) Run(run func(domain string)) *RBACProvider_GetDomainRBAC_Call

+ func (_c *RBACProvider_GetDomainRBAC_Call) RunAndReturn(run func(domain string) core.AccessControl) *RBACProvider_GetDomainRBAC_Call

+ type ReleaseRepository struct

+ func NewReleaseRepository(t interface{ ... }) *ReleaseRepository

+ func (_m *ReleaseRepository) EXPECT() *ReleaseRepository_Expecter

+ func (_mock *ReleaseRepository) Activate(tx core.DB, id uuid.UUID) error

+ func (_mock *ReleaseRepository) All() ([]models.Release, error)

+ func (_mock *ReleaseRepository) Begin() core.DB

+ func (_mock *ReleaseRepository) Create(tx core.DB, t *models.Release) error

+ func (_mock *ReleaseRepository) CreateBatch(tx core.DB, ts []models.Release) error

+ func (_mock *ReleaseRepository) CreateReleaseItem(tx core.DB, item *models.ReleaseItem) error

+ func (_mock *ReleaseRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *ReleaseRepository) DeleteBatch(tx core.DB, ids []models.Release) error

+ func (_mock *ReleaseRepository) DeleteReleaseItem(tx core.DB, id uuid.UUID) error

+ func (_mock *ReleaseRepository) GetByProjectID(projectID uuid.UUID) ([]models.Release, error)

+ func (_mock *ReleaseRepository) GetByProjectIDPaged(tx core.DB, projectID uuid.UUID, pageInfo core.PageInfo, search string, ...) (core.Paged[models.Release], error)

+ func (_mock *ReleaseRepository) GetCandidateItemsForRelease(projectID uuid.UUID, releaseID *uuid.UUID) ([]models.Artifact, []models.Release, error)

+ func (_mock *ReleaseRepository) GetDB(tx core.DB) core.DB

+ func (_mock *ReleaseRepository) List(ids []uuid.UUID) ([]models.Release, error)

+ func (_mock *ReleaseRepository) Read(id uuid.UUID) (models.Release, error)

+ func (_mock *ReleaseRepository) ReadRecursive(id uuid.UUID) (models.Release, error)

+ func (_mock *ReleaseRepository) ReadWithItems(id uuid.UUID) (models.Release, error)

+ func (_mock *ReleaseRepository) Save(tx core.DB, t *models.Release) error

+ func (_mock *ReleaseRepository) SaveBatch(tx core.DB, ts []models.Release) error

+ func (_mock *ReleaseRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *ReleaseRepository) Upsert(t *[]*models.Release, conflictingColumns []clause.Column, updateOnly []string) error

+ type ReleaseRepository_Activate_Call struct

+ func (_c *ReleaseRepository_Activate_Call) Return(err error) *ReleaseRepository_Activate_Call

+ func (_c *ReleaseRepository_Activate_Call) Run(run func(tx core.DB, id uuid.UUID)) *ReleaseRepository_Activate_Call

+ func (_c *ReleaseRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *ReleaseRepository_Activate_Call

+ type ReleaseRepository_All_Call struct

+ func (_c *ReleaseRepository_All_Call) Return(releases []models.Release, err error) *ReleaseRepository_All_Call

+ func (_c *ReleaseRepository_All_Call) Run(run func()) *ReleaseRepository_All_Call

+ func (_c *ReleaseRepository_All_Call) RunAndReturn(run func() ([]models.Release, error)) *ReleaseRepository_All_Call

+ type ReleaseRepository_Begin_Call struct

+ func (_c *ReleaseRepository_Begin_Call) Return(v core.DB) *ReleaseRepository_Begin_Call

+ func (_c *ReleaseRepository_Begin_Call) Run(run func()) *ReleaseRepository_Begin_Call

+ func (_c *ReleaseRepository_Begin_Call) RunAndReturn(run func() core.DB) *ReleaseRepository_Begin_Call

+ type ReleaseRepository_CreateBatch_Call struct

+ func (_c *ReleaseRepository_CreateBatch_Call) Return(err error) *ReleaseRepository_CreateBatch_Call

+ func (_c *ReleaseRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.Release)) *ReleaseRepository_CreateBatch_Call

+ func (_c *ReleaseRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Release) error) *ReleaseRepository_CreateBatch_Call

+ type ReleaseRepository_CreateReleaseItem_Call struct

+ func (_c *ReleaseRepository_CreateReleaseItem_Call) Return(err error) *ReleaseRepository_CreateReleaseItem_Call

+ func (_c *ReleaseRepository_CreateReleaseItem_Call) Run(run func(tx core.DB, item *models.ReleaseItem)) *ReleaseRepository_CreateReleaseItem_Call

+ func (_c *ReleaseRepository_CreateReleaseItem_Call) RunAndReturn(run func(tx core.DB, item *models.ReleaseItem) error) *ReleaseRepository_CreateReleaseItem_Call

+ type ReleaseRepository_Create_Call struct

+ func (_c *ReleaseRepository_Create_Call) Return(err error) *ReleaseRepository_Create_Call

+ func (_c *ReleaseRepository_Create_Call) Run(run func(tx core.DB, t *models.Release)) *ReleaseRepository_Create_Call

+ func (_c *ReleaseRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.Release) error) *ReleaseRepository_Create_Call

+ type ReleaseRepository_DeleteBatch_Call struct

+ func (_c *ReleaseRepository_DeleteBatch_Call) Return(err error) *ReleaseRepository_DeleteBatch_Call

+ func (_c *ReleaseRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.Release)) *ReleaseRepository_DeleteBatch_Call

+ func (_c *ReleaseRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.Release) error) *ReleaseRepository_DeleteBatch_Call

+ type ReleaseRepository_DeleteReleaseItem_Call struct

+ func (_c *ReleaseRepository_DeleteReleaseItem_Call) Return(err error) *ReleaseRepository_DeleteReleaseItem_Call

+ func (_c *ReleaseRepository_DeleteReleaseItem_Call) Run(run func(tx core.DB, id uuid.UUID)) *ReleaseRepository_DeleteReleaseItem_Call

+ func (_c *ReleaseRepository_DeleteReleaseItem_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *ReleaseRepository_DeleteReleaseItem_Call

+ type ReleaseRepository_Delete_Call struct

+ func (_c *ReleaseRepository_Delete_Call) Return(err error) *ReleaseRepository_Delete_Call

+ func (_c *ReleaseRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *ReleaseRepository_Delete_Call

+ func (_c *ReleaseRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *ReleaseRepository_Delete_Call

+ type ReleaseRepository_Expecter struct

+ func (_e *ReleaseRepository_Expecter) Activate(tx interface{}, id interface{}) *ReleaseRepository_Activate_Call

+ func (_e *ReleaseRepository_Expecter) All() *ReleaseRepository_All_Call

+ func (_e *ReleaseRepository_Expecter) Begin() *ReleaseRepository_Begin_Call

+ func (_e *ReleaseRepository_Expecter) Create(tx interface{}, t interface{}) *ReleaseRepository_Create_Call

+ func (_e *ReleaseRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *ReleaseRepository_CreateBatch_Call

+ func (_e *ReleaseRepository_Expecter) CreateReleaseItem(tx interface{}, item interface{}) *ReleaseRepository_CreateReleaseItem_Call

+ func (_e *ReleaseRepository_Expecter) Delete(tx interface{}, id interface{}) *ReleaseRepository_Delete_Call

+ func (_e *ReleaseRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *ReleaseRepository_DeleteBatch_Call

+ func (_e *ReleaseRepository_Expecter) DeleteReleaseItem(tx interface{}, id interface{}) *ReleaseRepository_DeleteReleaseItem_Call

+ func (_e *ReleaseRepository_Expecter) GetByProjectID(projectID interface{}) *ReleaseRepository_GetByProjectID_Call

+ func (_e *ReleaseRepository_Expecter) GetByProjectIDPaged(tx interface{}, projectID interface{}, pageInfo interface{}, ...) *ReleaseRepository_GetByProjectIDPaged_Call

+ func (_e *ReleaseRepository_Expecter) GetCandidateItemsForRelease(projectID interface{}, releaseID interface{}) *ReleaseRepository_GetCandidateItemsForRelease_Call

+ func (_e *ReleaseRepository_Expecter) GetDB(tx interface{}) *ReleaseRepository_GetDB_Call

+ func (_e *ReleaseRepository_Expecter) List(ids interface{}) *ReleaseRepository_List_Call

+ func (_e *ReleaseRepository_Expecter) Read(id interface{}) *ReleaseRepository_Read_Call

+ func (_e *ReleaseRepository_Expecter) ReadRecursive(id interface{}) *ReleaseRepository_ReadRecursive_Call

+ func (_e *ReleaseRepository_Expecter) ReadWithItems(id interface{}) *ReleaseRepository_ReadWithItems_Call

+ func (_e *ReleaseRepository_Expecter) Save(tx interface{}, t interface{}) *ReleaseRepository_Save_Call

+ func (_e *ReleaseRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *ReleaseRepository_SaveBatch_Call

+ func (_e *ReleaseRepository_Expecter) Transaction(fn interface{}) *ReleaseRepository_Transaction_Call

+ func (_e *ReleaseRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *ReleaseRepository_Upsert_Call

+ type ReleaseRepository_GetByProjectIDPaged_Call struct

+ func (_c *ReleaseRepository_GetByProjectIDPaged_Call) Return(paged core.Paged[models.Release], err error) *ReleaseRepository_GetByProjectIDPaged_Call

+ func (_c *ReleaseRepository_GetByProjectIDPaged_Call) Run(...) *ReleaseRepository_GetByProjectIDPaged_Call

+ func (_c *ReleaseRepository_GetByProjectIDPaged_Call) RunAndReturn(...) *ReleaseRepository_GetByProjectIDPaged_Call

+ type ReleaseRepository_GetByProjectID_Call struct

+ func (_c *ReleaseRepository_GetByProjectID_Call) Return(releases []models.Release, err error) *ReleaseRepository_GetByProjectID_Call

+ func (_c *ReleaseRepository_GetByProjectID_Call) Run(run func(projectID uuid.UUID)) *ReleaseRepository_GetByProjectID_Call

+ func (_c *ReleaseRepository_GetByProjectID_Call) RunAndReturn(run func(projectID uuid.UUID) ([]models.Release, error)) *ReleaseRepository_GetByProjectID_Call

+ type ReleaseRepository_GetCandidateItemsForRelease_Call struct

+ func (_c *ReleaseRepository_GetCandidateItemsForRelease_Call) Return(artifacts []models.Artifact, releases []models.Release, err error) *ReleaseRepository_GetCandidateItemsForRelease_Call

+ func (_c *ReleaseRepository_GetCandidateItemsForRelease_Call) Run(run func(projectID uuid.UUID, releaseID *uuid.UUID)) *ReleaseRepository_GetCandidateItemsForRelease_Call

+ func (_c *ReleaseRepository_GetCandidateItemsForRelease_Call) RunAndReturn(...) *ReleaseRepository_GetCandidateItemsForRelease_Call

+ type ReleaseRepository_GetDB_Call struct

+ func (_c *ReleaseRepository_GetDB_Call) Return(v core.DB) *ReleaseRepository_GetDB_Call

+ func (_c *ReleaseRepository_GetDB_Call) Run(run func(tx core.DB)) *ReleaseRepository_GetDB_Call

+ func (_c *ReleaseRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *ReleaseRepository_GetDB_Call

+ type ReleaseRepository_List_Call struct

+ func (_c *ReleaseRepository_List_Call) Return(releases []models.Release, err error) *ReleaseRepository_List_Call

+ func (_c *ReleaseRepository_List_Call) Run(run func(ids []uuid.UUID)) *ReleaseRepository_List_Call

+ func (_c *ReleaseRepository_List_Call) RunAndReturn(run func(ids []uuid.UUID) ([]models.Release, error)) *ReleaseRepository_List_Call

+ type ReleaseRepository_ReadRecursive_Call struct

+ func (_c *ReleaseRepository_ReadRecursive_Call) Return(release models.Release, err error) *ReleaseRepository_ReadRecursive_Call

+ func (_c *ReleaseRepository_ReadRecursive_Call) Run(run func(id uuid.UUID)) *ReleaseRepository_ReadRecursive_Call

+ func (_c *ReleaseRepository_ReadRecursive_Call) RunAndReturn(run func(id uuid.UUID) (models.Release, error)) *ReleaseRepository_ReadRecursive_Call

+ type ReleaseRepository_ReadWithItems_Call struct

+ func (_c *ReleaseRepository_ReadWithItems_Call) Return(release models.Release, err error) *ReleaseRepository_ReadWithItems_Call

+ func (_c *ReleaseRepository_ReadWithItems_Call) Run(run func(id uuid.UUID)) *ReleaseRepository_ReadWithItems_Call

+ func (_c *ReleaseRepository_ReadWithItems_Call) RunAndReturn(run func(id uuid.UUID) (models.Release, error)) *ReleaseRepository_ReadWithItems_Call

+ type ReleaseRepository_Read_Call struct

+ func (_c *ReleaseRepository_Read_Call) Return(release models.Release, err error) *ReleaseRepository_Read_Call

+ func (_c *ReleaseRepository_Read_Call) Run(run func(id uuid.UUID)) *ReleaseRepository_Read_Call

+ func (_c *ReleaseRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.Release, error)) *ReleaseRepository_Read_Call

+ type ReleaseRepository_SaveBatch_Call struct

+ func (_c *ReleaseRepository_SaveBatch_Call) Return(err error) *ReleaseRepository_SaveBatch_Call

+ func (_c *ReleaseRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.Release)) *ReleaseRepository_SaveBatch_Call

+ func (_c *ReleaseRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.Release) error) *ReleaseRepository_SaveBatch_Call

+ type ReleaseRepository_Save_Call struct

+ func (_c *ReleaseRepository_Save_Call) Return(err error) *ReleaseRepository_Save_Call

+ func (_c *ReleaseRepository_Save_Call) Run(run func(tx core.DB, t *models.Release)) *ReleaseRepository_Save_Call

+ func (_c *ReleaseRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.Release) error) *ReleaseRepository_Save_Call

+ type ReleaseRepository_Transaction_Call struct

+ func (_c *ReleaseRepository_Transaction_Call) Return(err error) *ReleaseRepository_Transaction_Call

+ func (_c *ReleaseRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *ReleaseRepository_Transaction_Call

+ func (_c *ReleaseRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *ReleaseRepository_Transaction_Call

+ type ReleaseRepository_Upsert_Call struct

+ func (_c *ReleaseRepository_Upsert_Call) Return(err error) *ReleaseRepository_Upsert_Call

+ func (_c *ReleaseRepository_Upsert_Call) Run(...) *ReleaseRepository_Upsert_Call

+ func (_c *ReleaseRepository_Upsert_Call) RunAndReturn(...) *ReleaseRepository_Upsert_Call

+ type SBOM struct

+ func NewSBOM(t interface{ ... }) *SBOM

+ func (_m *SBOM) EXPECT() *SBOM_Expecter

+ func (_mock *SBOM) GetCdxBom() *cyclonedx.BOM

+ func (_mock *SBOM) GetComponents() *[]cyclonedx.Component

+ func (_mock *SBOM) GetDependencies() *[]cyclonedx.Dependency

+ func (_mock *SBOM) GetMetadata() *cyclonedx.Metadata

+ type SBOMScanner struct

+ func NewSBOMScanner(t interface{ ... }) *SBOMScanner

+ func (_m *SBOMScanner) EXPECT() *SBOMScanner_Expecter

+ func (_mock *SBOMScanner) Scan(bom normalize.SBOM) ([]models.VulnInPackage, error)

+ type SBOMScanner_Expecter struct

+ func (_e *SBOMScanner_Expecter) Scan(bom interface{}) *SBOMScanner_Scan_Call

+ type SBOMScanner_Scan_Call struct

+ func (_c *SBOMScanner_Scan_Call) Return(vulnInPackages []models.VulnInPackage, err error) *SBOMScanner_Scan_Call

+ func (_c *SBOMScanner_Scan_Call) Run(run func(bom normalize.SBOM)) *SBOMScanner_Scan_Call

+ func (_c *SBOMScanner_Scan_Call) RunAndReturn(run func(bom normalize.SBOM) ([]models.VulnInPackage, error)) *SBOMScanner_Scan_Call

+ type SBOM_Expecter struct

+ func (_e *SBOM_Expecter) GetCdxBom() *SBOM_GetCdxBom_Call

+ func (_e *SBOM_Expecter) GetComponents() *SBOM_GetComponents_Call

+ func (_e *SBOM_Expecter) GetDependencies() *SBOM_GetDependencies_Call

+ func (_e *SBOM_Expecter) GetMetadata() *SBOM_GetMetadata_Call

+ type SBOM_GetCdxBom_Call struct

+ func (_c *SBOM_GetCdxBom_Call) Return(bOM *cyclonedx.BOM) *SBOM_GetCdxBom_Call

+ func (_c *SBOM_GetCdxBom_Call) Run(run func()) *SBOM_GetCdxBom_Call

+ func (_c *SBOM_GetCdxBom_Call) RunAndReturn(run func() *cyclonedx.BOM) *SBOM_GetCdxBom_Call

+ type SBOM_GetComponents_Call struct

+ func (_c *SBOM_GetComponents_Call) Return(components *[]cyclonedx.Component) *SBOM_GetComponents_Call

+ func (_c *SBOM_GetComponents_Call) Run(run func()) *SBOM_GetComponents_Call

+ func (_c *SBOM_GetComponents_Call) RunAndReturn(run func() *[]cyclonedx.Component) *SBOM_GetComponents_Call

+ type SBOM_GetDependencies_Call struct

+ func (_c *SBOM_GetDependencies_Call) Return(dependencys *[]cyclonedx.Dependency) *SBOM_GetDependencies_Call

+ func (_c *SBOM_GetDependencies_Call) Run(run func()) *SBOM_GetDependencies_Call

+ func (_c *SBOM_GetDependencies_Call) RunAndReturn(run func() *[]cyclonedx.Dependency) *SBOM_GetDependencies_Call

+ type SBOM_GetMetadata_Call struct

+ func (_c *SBOM_GetMetadata_Call) Return(metadata *cyclonedx.Metadata) *SBOM_GetMetadata_Call

+ func (_c *SBOM_GetMetadata_Call) Run(run func()) *SBOM_GetMetadata_Call

+ func (_c *SBOM_GetMetadata_Call) RunAndReturn(run func() *cyclonedx.Metadata) *SBOM_GetMetadata_Call

+ type StatisticsRepository struct

+ func NewStatisticsRepository(t interface{ ... }) *StatisticsRepository

+ func (_m *StatisticsRepository) EXPECT() *StatisticsRepository_Expecter

+ func (_mock *StatisticsRepository) AverageFixingTime(artifactNam *string, assetVersionName string, assetID uuid.UUID, ...) (time.Duration, error)

+ func (_mock *StatisticsRepository) AverageFixingTimeByCvss(artifactName *string, assetVersionName string, assetID uuid.UUID, ...) (time.Duration, error)

+ func (_mock *StatisticsRepository) AverageFixingTimeByCvssForRelease(releaseID uuid.UUID, cvssIntervalStart float64, cvssIntervalEnd float64) (time.Duration, error)

+ func (_mock *StatisticsRepository) AverageFixingTimeForRelease(releaseID uuid.UUID, riskIntervalStart float64, riskIntervalEnd float64) (time.Duration, error)

+ func (_mock *StatisticsRepository) CVESWithKnownExploitsInAssetVersion(assetVersion models.AssetVersion) ([]models.CVE, error)

+ func (_mock *StatisticsRepository) TimeTravelDependencyVulnState(artifactName *string, assetVersionName string, assetID uuid.UUID, ...) ([]models.DependencyVuln, error)

+ type StatisticsRepository_AverageFixingTimeByCvssForRelease_Call struct

+ func (_c *StatisticsRepository_AverageFixingTimeByCvssForRelease_Call) Return(duration time.Duration, err error) *StatisticsRepository_AverageFixingTimeByCvssForRelease_Call

+ func (_c *StatisticsRepository_AverageFixingTimeByCvssForRelease_Call) Run(...) *StatisticsRepository_AverageFixingTimeByCvssForRelease_Call

+ func (_c *StatisticsRepository_AverageFixingTimeByCvssForRelease_Call) RunAndReturn(...) *StatisticsRepository_AverageFixingTimeByCvssForRelease_Call

+ type StatisticsRepository_AverageFixingTimeByCvss_Call struct

+ func (_c *StatisticsRepository_AverageFixingTimeByCvss_Call) Return(duration time.Duration, err error) *StatisticsRepository_AverageFixingTimeByCvss_Call

+ func (_c *StatisticsRepository_AverageFixingTimeByCvss_Call) Run(...) *StatisticsRepository_AverageFixingTimeByCvss_Call

+ func (_c *StatisticsRepository_AverageFixingTimeByCvss_Call) RunAndReturn(...) *StatisticsRepository_AverageFixingTimeByCvss_Call

+ type StatisticsRepository_AverageFixingTimeForRelease_Call struct

+ func (_c *StatisticsRepository_AverageFixingTimeForRelease_Call) Return(duration time.Duration, err error) *StatisticsRepository_AverageFixingTimeForRelease_Call

+ func (_c *StatisticsRepository_AverageFixingTimeForRelease_Call) Run(...) *StatisticsRepository_AverageFixingTimeForRelease_Call

+ func (_c *StatisticsRepository_AverageFixingTimeForRelease_Call) RunAndReturn(...) *StatisticsRepository_AverageFixingTimeForRelease_Call

+ type StatisticsRepository_AverageFixingTime_Call struct

+ func (_c *StatisticsRepository_AverageFixingTime_Call) Return(duration time.Duration, err error) *StatisticsRepository_AverageFixingTime_Call

+ func (_c *StatisticsRepository_AverageFixingTime_Call) Run(run func(artifactNam *string, assetVersionName string, assetID uuid.UUID, ...)) *StatisticsRepository_AverageFixingTime_Call

+ func (_c *StatisticsRepository_AverageFixingTime_Call) RunAndReturn(...) *StatisticsRepository_AverageFixingTime_Call

+ type StatisticsRepository_CVESWithKnownExploitsInAssetVersion_Call struct

+ func (_c *StatisticsRepository_CVESWithKnownExploitsInAssetVersion_Call) Return(cVEs []models.CVE, err error) *StatisticsRepository_CVESWithKnownExploitsInAssetVersion_Call

+ func (_c *StatisticsRepository_CVESWithKnownExploitsInAssetVersion_Call) Run(run func(assetVersion models.AssetVersion)) *StatisticsRepository_CVESWithKnownExploitsInAssetVersion_Call

+ func (_c *StatisticsRepository_CVESWithKnownExploitsInAssetVersion_Call) RunAndReturn(run func(assetVersion models.AssetVersion) ([]models.CVE, error)) *StatisticsRepository_CVESWithKnownExploitsInAssetVersion_Call

+ type StatisticsRepository_Expecter struct

+ func (_e *StatisticsRepository_Expecter) AverageFixingTime(artifactNam interface{}, assetVersionName interface{}, assetID interface{}, ...) *StatisticsRepository_AverageFixingTime_Call

+ func (_e *StatisticsRepository_Expecter) AverageFixingTimeByCvss(artifactName interface{}, assetVersionName interface{}, assetID interface{}, ...) *StatisticsRepository_AverageFixingTimeByCvss_Call

+ func (_e *StatisticsRepository_Expecter) AverageFixingTimeByCvssForRelease(releaseID interface{}, cvssIntervalStart interface{}, ...) *StatisticsRepository_AverageFixingTimeByCvssForRelease_Call

+ func (_e *StatisticsRepository_Expecter) AverageFixingTimeForRelease(releaseID interface{}, riskIntervalStart interface{}, ...) *StatisticsRepository_AverageFixingTimeForRelease_Call

+ func (_e *StatisticsRepository_Expecter) CVESWithKnownExploitsInAssetVersion(assetVersion interface{}) *StatisticsRepository_CVESWithKnownExploitsInAssetVersion_Call

+ func (_e *StatisticsRepository_Expecter) TimeTravelDependencyVulnState(artifactName interface{}, assetVersionName interface{}, assetID interface{}, ...) *StatisticsRepository_TimeTravelDependencyVulnState_Call

+ type StatisticsRepository_TimeTravelDependencyVulnState_Call struct

+ func (_c *StatisticsRepository_TimeTravelDependencyVulnState_Call) Return(dependencyVulns []models.DependencyVuln, err error) *StatisticsRepository_TimeTravelDependencyVulnState_Call

+ func (_c *StatisticsRepository_TimeTravelDependencyVulnState_Call) Run(...) *StatisticsRepository_TimeTravelDependencyVulnState_Call

+ func (_c *StatisticsRepository_TimeTravelDependencyVulnState_Call) RunAndReturn(...) *StatisticsRepository_TimeTravelDependencyVulnState_Call

+ type StatisticsService struct

+ func NewStatisticsService(t interface{ ... }) *StatisticsService

+ func (_m *StatisticsService) EXPECT() *StatisticsService_Expecter

+ func (_mock *StatisticsService) GetArtifactRiskHistory(artifactName *string, assetVersionName string, assetID uuid.UUID, ...) ([]models.ArtifactRiskHistory, error)

+ func (_mock *StatisticsService) GetAverageFixingTime(artifactName *string, assetVersionName string, assetID uuid.UUID, ...) (time.Duration, error)

+ func (_mock *StatisticsService) GetAverageFixingTimeByCvss(artifactName *string, assetVersionName string, assetID uuid.UUID, ...) (time.Duration, error)

+ func (_mock *StatisticsService) GetAverageFixingTimeByCvssForRelease(releaseID uuid.UUID, severity string) (time.Duration, error)

+ func (_mock *StatisticsService) GetAverageFixingTimeForRelease(releaseID uuid.UUID, severity string) (time.Duration, error)

+ func (_mock *StatisticsService) GetComponentRisk(artifactName *string, assetVersionName string, assetID uuid.UUID) (map[string]models.Distribution, error)

+ func (_mock *StatisticsService) GetReleaseRiskHistory(releaseID uuid.UUID, start time.Time, end time.Time) ([]models.ArtifactRiskHistory, error)

+ func (_mock *StatisticsService) UpdateArtifactRiskAggregation(artifact *models.Artifact, assetID uuid.UUID, begin time.Time, end time.Time) error

+ type StatisticsService_Expecter struct

+ func (_e *StatisticsService_Expecter) GetArtifactRiskHistory(artifactName interface{}, assetVersionName interface{}, assetID interface{}, ...) *StatisticsService_GetArtifactRiskHistory_Call

+ func (_e *StatisticsService_Expecter) GetAverageFixingTime(artifactName interface{}, assetVersionName interface{}, assetID interface{}, ...) *StatisticsService_GetAverageFixingTime_Call

+ func (_e *StatisticsService_Expecter) GetAverageFixingTimeByCvss(artifactName interface{}, assetVersionName interface{}, assetID interface{}, ...) *StatisticsService_GetAverageFixingTimeByCvss_Call

+ func (_e *StatisticsService_Expecter) GetAverageFixingTimeByCvssForRelease(releaseID interface{}, severity interface{}) *StatisticsService_GetAverageFixingTimeByCvssForRelease_Call

+ func (_e *StatisticsService_Expecter) GetAverageFixingTimeForRelease(releaseID interface{}, severity interface{}) *StatisticsService_GetAverageFixingTimeForRelease_Call

+ func (_e *StatisticsService_Expecter) GetComponentRisk(artifactName interface{}, assetVersionName interface{}, assetID interface{}) *StatisticsService_GetComponentRisk_Call

+ func (_e *StatisticsService_Expecter) GetReleaseRiskHistory(releaseID interface{}, start interface{}, end interface{}) *StatisticsService_GetReleaseRiskHistory_Call

+ func (_e *StatisticsService_Expecter) UpdateArtifactRiskAggregation(artifact interface{}, assetID interface{}, begin interface{}, end interface{}) *StatisticsService_UpdateArtifactRiskAggregation_Call

+ type StatisticsService_GetArtifactRiskHistory_Call struct

+ func (_c *StatisticsService_GetArtifactRiskHistory_Call) Return(artifactRiskHistorys []models.ArtifactRiskHistory, err error) *StatisticsService_GetArtifactRiskHistory_Call

+ func (_c *StatisticsService_GetArtifactRiskHistory_Call) Run(...) *StatisticsService_GetArtifactRiskHistory_Call

+ func (_c *StatisticsService_GetArtifactRiskHistory_Call) RunAndReturn(...) *StatisticsService_GetArtifactRiskHistory_Call

+ type StatisticsService_GetAverageFixingTimeByCvssForRelease_Call struct

+ func (_c *StatisticsService_GetAverageFixingTimeByCvssForRelease_Call) Return(duration time.Duration, err error) *StatisticsService_GetAverageFixingTimeByCvssForRelease_Call

+ func (_c *StatisticsService_GetAverageFixingTimeByCvssForRelease_Call) Run(run func(releaseID uuid.UUID, severity string)) *StatisticsService_GetAverageFixingTimeByCvssForRelease_Call

+ func (_c *StatisticsService_GetAverageFixingTimeByCvssForRelease_Call) RunAndReturn(run func(releaseID uuid.UUID, severity string) (time.Duration, error)) *StatisticsService_GetAverageFixingTimeByCvssForRelease_Call

+ type StatisticsService_GetAverageFixingTimeByCvss_Call struct

+ func (_c *StatisticsService_GetAverageFixingTimeByCvss_Call) Return(duration time.Duration, err error) *StatisticsService_GetAverageFixingTimeByCvss_Call

+ func (_c *StatisticsService_GetAverageFixingTimeByCvss_Call) Run(...) *StatisticsService_GetAverageFixingTimeByCvss_Call

+ func (_c *StatisticsService_GetAverageFixingTimeByCvss_Call) RunAndReturn(...) *StatisticsService_GetAverageFixingTimeByCvss_Call

+ type StatisticsService_GetAverageFixingTimeForRelease_Call struct

+ func (_c *StatisticsService_GetAverageFixingTimeForRelease_Call) Return(duration time.Duration, err error) *StatisticsService_GetAverageFixingTimeForRelease_Call

+ func (_c *StatisticsService_GetAverageFixingTimeForRelease_Call) Run(run func(releaseID uuid.UUID, severity string)) *StatisticsService_GetAverageFixingTimeForRelease_Call

+ func (_c *StatisticsService_GetAverageFixingTimeForRelease_Call) RunAndReturn(run func(releaseID uuid.UUID, severity string) (time.Duration, error)) *StatisticsService_GetAverageFixingTimeForRelease_Call

+ type StatisticsService_GetAverageFixingTime_Call struct

+ func (_c *StatisticsService_GetAverageFixingTime_Call) Return(duration time.Duration, err error) *StatisticsService_GetAverageFixingTime_Call

+ func (_c *StatisticsService_GetAverageFixingTime_Call) Run(...) *StatisticsService_GetAverageFixingTime_Call

+ func (_c *StatisticsService_GetAverageFixingTime_Call) RunAndReturn(...) *StatisticsService_GetAverageFixingTime_Call

+ type StatisticsService_GetComponentRisk_Call struct

+ func (_c *StatisticsService_GetComponentRisk_Call) Return(stringToDistribution map[string]models.Distribution, err error) *StatisticsService_GetComponentRisk_Call

+ func (_c *StatisticsService_GetComponentRisk_Call) Run(run func(artifactName *string, assetVersionName string, assetID uuid.UUID)) *StatisticsService_GetComponentRisk_Call

+ func (_c *StatisticsService_GetComponentRisk_Call) RunAndReturn(...) *StatisticsService_GetComponentRisk_Call

+ type StatisticsService_GetReleaseRiskHistory_Call struct

+ func (_c *StatisticsService_GetReleaseRiskHistory_Call) Return(artifactRiskHistorys []models.ArtifactRiskHistory, err error) *StatisticsService_GetReleaseRiskHistory_Call

+ func (_c *StatisticsService_GetReleaseRiskHistory_Call) Run(run func(releaseID uuid.UUID, start time.Time, end time.Time)) *StatisticsService_GetReleaseRiskHistory_Call

+ func (_c *StatisticsService_GetReleaseRiskHistory_Call) RunAndReturn(...) *StatisticsService_GetReleaseRiskHistory_Call

+ type StatisticsService_UpdateArtifactRiskAggregation_Call struct

+ func (_c *StatisticsService_UpdateArtifactRiskAggregation_Call) Return(err error) *StatisticsService_UpdateArtifactRiskAggregation_Call

+ func (_c *StatisticsService_UpdateArtifactRiskAggregation_Call) Run(...) *StatisticsService_UpdateArtifactRiskAggregation_Call

+ func (_c *StatisticsService_UpdateArtifactRiskAggregation_Call) RunAndReturn(...) *StatisticsService_UpdateArtifactRiskAggregation_Call

+ type SupplyChainRepository struct

+ func NewSupplyChainRepository(t interface{ ... }) *SupplyChainRepository

+ func (_m *SupplyChainRepository) EXPECT() *SupplyChainRepository_Expecter

+ func (_mock *SupplyChainRepository) Activate(tx core.DB, id uuid.UUID) error

+ func (_mock *SupplyChainRepository) All() ([]models.SupplyChain, error)

+ func (_mock *SupplyChainRepository) Begin() core.DB

+ func (_mock *SupplyChainRepository) Create(tx core.DB, t *models.SupplyChain) error

+ func (_mock *SupplyChainRepository) CreateBatch(tx core.DB, ts []models.SupplyChain) error

+ func (_mock *SupplyChainRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *SupplyChainRepository) DeleteBatch(tx core.DB, ids []models.SupplyChain) error

+ func (_mock *SupplyChainRepository) FindByDigest(digest string) ([]models.SupplyChain, error)

+ func (_mock *SupplyChainRepository) FindBySupplyChainID(supplyChainID string) ([]models.SupplyChain, error)

+ func (_mock *SupplyChainRepository) GetDB(tx core.DB) core.DB

+ func (_mock *SupplyChainRepository) List(ids []uuid.UUID) ([]models.SupplyChain, error)

+ func (_mock *SupplyChainRepository) PercentageOfVerifiedSupplyChains(assetVersionName string, assetID uuid.UUID) (float64, error)

+ func (_mock *SupplyChainRepository) Read(id uuid.UUID) (models.SupplyChain, error)

+ func (_mock *SupplyChainRepository) Save(tx core.DB, t *models.SupplyChain) error

+ func (_mock *SupplyChainRepository) SaveBatch(tx core.DB, ts []models.SupplyChain) error

+ func (_mock *SupplyChainRepository) Transaction(fn func(tx core.DB) error) error

+ func (_mock *SupplyChainRepository) Upsert(t *[]*models.SupplyChain, conflictingColumns []clause.Column, ...) error

+ type SupplyChainRepository_Activate_Call struct

+ func (_c *SupplyChainRepository_Activate_Call) Return(err error) *SupplyChainRepository_Activate_Call

+ func (_c *SupplyChainRepository_Activate_Call) Run(run func(tx core.DB, id uuid.UUID)) *SupplyChainRepository_Activate_Call

+ func (_c *SupplyChainRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *SupplyChainRepository_Activate_Call

+ type SupplyChainRepository_All_Call struct

+ func (_c *SupplyChainRepository_All_Call) Return(supplyChains []models.SupplyChain, err error) *SupplyChainRepository_All_Call

+ func (_c *SupplyChainRepository_All_Call) Run(run func()) *SupplyChainRepository_All_Call

+ func (_c *SupplyChainRepository_All_Call) RunAndReturn(run func() ([]models.SupplyChain, error)) *SupplyChainRepository_All_Call

+ type SupplyChainRepository_Begin_Call struct

+ func (_c *SupplyChainRepository_Begin_Call) Return(v core.DB) *SupplyChainRepository_Begin_Call

+ func (_c *SupplyChainRepository_Begin_Call) Run(run func()) *SupplyChainRepository_Begin_Call

+ func (_c *SupplyChainRepository_Begin_Call) RunAndReturn(run func() core.DB) *SupplyChainRepository_Begin_Call

+ type SupplyChainRepository_CreateBatch_Call struct

+ func (_c *SupplyChainRepository_CreateBatch_Call) Return(err error) *SupplyChainRepository_CreateBatch_Call

+ func (_c *SupplyChainRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.SupplyChain)) *SupplyChainRepository_CreateBatch_Call

+ func (_c *SupplyChainRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.SupplyChain) error) *SupplyChainRepository_CreateBatch_Call

+ type SupplyChainRepository_Create_Call struct

+ func (_c *SupplyChainRepository_Create_Call) Return(err error) *SupplyChainRepository_Create_Call

+ func (_c *SupplyChainRepository_Create_Call) Run(run func(tx core.DB, t *models.SupplyChain)) *SupplyChainRepository_Create_Call

+ func (_c *SupplyChainRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.SupplyChain) error) *SupplyChainRepository_Create_Call

+ type SupplyChainRepository_DeleteBatch_Call struct

+ func (_c *SupplyChainRepository_DeleteBatch_Call) Return(err error) *SupplyChainRepository_DeleteBatch_Call

+ func (_c *SupplyChainRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.SupplyChain)) *SupplyChainRepository_DeleteBatch_Call

+ func (_c *SupplyChainRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.SupplyChain) error) *SupplyChainRepository_DeleteBatch_Call

+ type SupplyChainRepository_Delete_Call struct

+ func (_c *SupplyChainRepository_Delete_Call) Return(err error) *SupplyChainRepository_Delete_Call

+ func (_c *SupplyChainRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *SupplyChainRepository_Delete_Call

+ func (_c *SupplyChainRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *SupplyChainRepository_Delete_Call

+ type SupplyChainRepository_Expecter struct

+ func (_e *SupplyChainRepository_Expecter) Activate(tx interface{}, id interface{}) *SupplyChainRepository_Activate_Call

+ func (_e *SupplyChainRepository_Expecter) All() *SupplyChainRepository_All_Call

+ func (_e *SupplyChainRepository_Expecter) Begin() *SupplyChainRepository_Begin_Call

+ func (_e *SupplyChainRepository_Expecter) Create(tx interface{}, t interface{}) *SupplyChainRepository_Create_Call

+ func (_e *SupplyChainRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *SupplyChainRepository_CreateBatch_Call

+ func (_e *SupplyChainRepository_Expecter) Delete(tx interface{}, id interface{}) *SupplyChainRepository_Delete_Call

+ func (_e *SupplyChainRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *SupplyChainRepository_DeleteBatch_Call

+ func (_e *SupplyChainRepository_Expecter) FindByDigest(digest interface{}) *SupplyChainRepository_FindByDigest_Call

+ func (_e *SupplyChainRepository_Expecter) FindBySupplyChainID(supplyChainID interface{}) *SupplyChainRepository_FindBySupplyChainID_Call

+ func (_e *SupplyChainRepository_Expecter) GetDB(tx interface{}) *SupplyChainRepository_GetDB_Call

+ func (_e *SupplyChainRepository_Expecter) List(ids interface{}) *SupplyChainRepository_List_Call

+ func (_e *SupplyChainRepository_Expecter) PercentageOfVerifiedSupplyChains(assetVersionName interface{}, assetID interface{}) *SupplyChainRepository_PercentageOfVerifiedSupplyChains_Call

+ func (_e *SupplyChainRepository_Expecter) Read(id interface{}) *SupplyChainRepository_Read_Call

+ func (_e *SupplyChainRepository_Expecter) Save(tx interface{}, t interface{}) *SupplyChainRepository_Save_Call

+ func (_e *SupplyChainRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *SupplyChainRepository_SaveBatch_Call

+ func (_e *SupplyChainRepository_Expecter) Transaction(fn interface{}) *SupplyChainRepository_Transaction_Call

+ func (_e *SupplyChainRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *SupplyChainRepository_Upsert_Call

+ type SupplyChainRepository_FindByDigest_Call struct

+ func (_c *SupplyChainRepository_FindByDigest_Call) Return(supplyChains []models.SupplyChain, err error) *SupplyChainRepository_FindByDigest_Call

+ func (_c *SupplyChainRepository_FindByDigest_Call) Run(run func(digest string)) *SupplyChainRepository_FindByDigest_Call

+ func (_c *SupplyChainRepository_FindByDigest_Call) RunAndReturn(run func(digest string) ([]models.SupplyChain, error)) *SupplyChainRepository_FindByDigest_Call

+ type SupplyChainRepository_FindBySupplyChainID_Call struct

+ func (_c *SupplyChainRepository_FindBySupplyChainID_Call) Return(supplyChains []models.SupplyChain, err error) *SupplyChainRepository_FindBySupplyChainID_Call

+ func (_c *SupplyChainRepository_FindBySupplyChainID_Call) Run(run func(supplyChainID string)) *SupplyChainRepository_FindBySupplyChainID_Call

+ func (_c *SupplyChainRepository_FindBySupplyChainID_Call) RunAndReturn(run func(supplyChainID string) ([]models.SupplyChain, error)) *SupplyChainRepository_FindBySupplyChainID_Call

+ type SupplyChainRepository_GetDB_Call struct

+ func (_c *SupplyChainRepository_GetDB_Call) Return(v core.DB) *SupplyChainRepository_GetDB_Call

+ func (_c *SupplyChainRepository_GetDB_Call) Run(run func(tx core.DB)) *SupplyChainRepository_GetDB_Call

+ func (_c *SupplyChainRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *SupplyChainRepository_GetDB_Call

+ type SupplyChainRepository_List_Call struct

+ func (_c *SupplyChainRepository_List_Call) Return(supplyChains []models.SupplyChain, err error) *SupplyChainRepository_List_Call

+ func (_c *SupplyChainRepository_List_Call) Run(run func(ids []uuid.UUID)) *SupplyChainRepository_List_Call

+ func (_c *SupplyChainRepository_List_Call) RunAndReturn(run func(ids []uuid.UUID) ([]models.SupplyChain, error)) *SupplyChainRepository_List_Call

+ type SupplyChainRepository_PercentageOfVerifiedSupplyChains_Call struct

+ func (_c *SupplyChainRepository_PercentageOfVerifiedSupplyChains_Call) Return(f float64, err error) *SupplyChainRepository_PercentageOfVerifiedSupplyChains_Call

+ func (_c *SupplyChainRepository_PercentageOfVerifiedSupplyChains_Call) Run(run func(assetVersionName string, assetID uuid.UUID)) *SupplyChainRepository_PercentageOfVerifiedSupplyChains_Call

+ func (_c *SupplyChainRepository_PercentageOfVerifiedSupplyChains_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID) (float64, error)) *SupplyChainRepository_PercentageOfVerifiedSupplyChains_Call

+ type SupplyChainRepository_Read_Call struct

+ func (_c *SupplyChainRepository_Read_Call) Return(supplyChain models.SupplyChain, err error) *SupplyChainRepository_Read_Call

+ func (_c *SupplyChainRepository_Read_Call) Run(run func(id uuid.UUID)) *SupplyChainRepository_Read_Call

+ func (_c *SupplyChainRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.SupplyChain, error)) *SupplyChainRepository_Read_Call

+ type SupplyChainRepository_SaveBatch_Call struct

+ func (_c *SupplyChainRepository_SaveBatch_Call) Return(err error) *SupplyChainRepository_SaveBatch_Call

+ func (_c *SupplyChainRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.SupplyChain)) *SupplyChainRepository_SaveBatch_Call

+ func (_c *SupplyChainRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.SupplyChain) error) *SupplyChainRepository_SaveBatch_Call

+ type SupplyChainRepository_Save_Call struct

+ func (_c *SupplyChainRepository_Save_Call) Return(err error) *SupplyChainRepository_Save_Call

+ func (_c *SupplyChainRepository_Save_Call) Run(run func(tx core.DB, t *models.SupplyChain)) *SupplyChainRepository_Save_Call

+ func (_c *SupplyChainRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.SupplyChain) error) *SupplyChainRepository_Save_Call

+ type SupplyChainRepository_Transaction_Call struct

+ func (_c *SupplyChainRepository_Transaction_Call) Return(err error) *SupplyChainRepository_Transaction_Call

+ func (_c *SupplyChainRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *SupplyChainRepository_Transaction_Call

+ func (_c *SupplyChainRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *SupplyChainRepository_Transaction_Call

+ type SupplyChainRepository_Upsert_Call struct

+ func (_c *SupplyChainRepository_Upsert_Call) Return(err error) *SupplyChainRepository_Upsert_Call

+ func (_c *SupplyChainRepository_Upsert_Call) Run(run func(t *[]*models.SupplyChain, conflictingColumns []clause.Column, ...)) *SupplyChainRepository_Upsert_Call

+ func (_c *SupplyChainRepository_Upsert_Call) RunAndReturn(...) *SupplyChainRepository_Upsert_Call

+ type ThirdPartyIntegration struct

+ func NewThirdPartyIntegration(t interface{ ... }) *ThirdPartyIntegration

+ func (_m *ThirdPartyIntegration) EXPECT() *ThirdPartyIntegration_Expecter

+ func (_mock *ThirdPartyIntegration) CreateIssue(ctx context.Context, asset models.Asset, assetVersionName string, ...) error

+ func (_mock *ThirdPartyIntegration) GetID() core.IntegrationID

+ func (_mock *ThirdPartyIntegration) GetUsers(org models.Org) []core.User

+ func (_mock *ThirdPartyIntegration) HandleEvent(event any) error

+ func (_mock *ThirdPartyIntegration) HandleWebhook(ctx core.Context) error

+ func (_mock *ThirdPartyIntegration) HasAccessToExternalEntityProvider(ctx core.Context, externalEntityProviderID string) (bool, error)

+ func (_mock *ThirdPartyIntegration) ListGroups(ctx context.Context, userID string, providerID string) ([]models.Project, []core.Role, error)

+ func (_mock *ThirdPartyIntegration) ListOrgs(ctx core.Context) ([]models.Org, error)

+ func (_mock *ThirdPartyIntegration) ListProjects(ctx context.Context, userID string, providerID string, groupID string) ([]models.Asset, []core.Role, error)

+ func (_mock *ThirdPartyIntegration) ListRepositories(ctx core.Context) ([]core.Repository, error)

+ func (_mock *ThirdPartyIntegration) UpdateIssue(ctx context.Context, asset models.Asset, vuln models.Vuln) error

+ func (_mock *ThirdPartyIntegration) WantsToHandleWebhook(ctx core.Context) bool

+ type ThirdPartyIntegration_CreateIssue_Call struct

+ func (_c *ThirdPartyIntegration_CreateIssue_Call) Return(err error) *ThirdPartyIntegration_CreateIssue_Call

+ func (_c *ThirdPartyIntegration_CreateIssue_Call) Run(...) *ThirdPartyIntegration_CreateIssue_Call

+ func (_c *ThirdPartyIntegration_CreateIssue_Call) RunAndReturn(...) *ThirdPartyIntegration_CreateIssue_Call

+ type ThirdPartyIntegration_Expecter struct

+ func (_e *ThirdPartyIntegration_Expecter) CreateIssue(ctx interface{}, asset interface{}, assetVersionName interface{}, ...) *ThirdPartyIntegration_CreateIssue_Call

+ func (_e *ThirdPartyIntegration_Expecter) GetID() *ThirdPartyIntegration_GetID_Call

+ func (_e *ThirdPartyIntegration_Expecter) GetUsers(org interface{}) *ThirdPartyIntegration_GetUsers_Call

+ func (_e *ThirdPartyIntegration_Expecter) HandleEvent(event interface{}) *ThirdPartyIntegration_HandleEvent_Call

+ func (_e *ThirdPartyIntegration_Expecter) HandleWebhook(ctx interface{}) *ThirdPartyIntegration_HandleWebhook_Call

+ func (_e *ThirdPartyIntegration_Expecter) HasAccessToExternalEntityProvider(ctx interface{}, externalEntityProviderID interface{}) *ThirdPartyIntegration_HasAccessToExternalEntityProvider_Call

+ func (_e *ThirdPartyIntegration_Expecter) ListGroups(ctx interface{}, userID interface{}, providerID interface{}) *ThirdPartyIntegration_ListGroups_Call

+ func (_e *ThirdPartyIntegration_Expecter) ListOrgs(ctx interface{}) *ThirdPartyIntegration_ListOrgs_Call

+ func (_e *ThirdPartyIntegration_Expecter) ListProjects(ctx interface{}, userID interface{}, providerID interface{}, ...) *ThirdPartyIntegration_ListProjects_Call

+ func (_e *ThirdPartyIntegration_Expecter) ListRepositories(ctx interface{}) *ThirdPartyIntegration_ListRepositories_Call

+ func (_e *ThirdPartyIntegration_Expecter) UpdateIssue(ctx interface{}, asset interface{}, vuln interface{}) *ThirdPartyIntegration_UpdateIssue_Call

+ func (_e *ThirdPartyIntegration_Expecter) WantsToHandleWebhook(ctx interface{}) *ThirdPartyIntegration_WantsToHandleWebhook_Call

+ type ThirdPartyIntegration_GetID_Call struct

+ func (_c *ThirdPartyIntegration_GetID_Call) Return(integrationID core.IntegrationID) *ThirdPartyIntegration_GetID_Call

+ func (_c *ThirdPartyIntegration_GetID_Call) Run(run func()) *ThirdPartyIntegration_GetID_Call

+ func (_c *ThirdPartyIntegration_GetID_Call) RunAndReturn(run func() core.IntegrationID) *ThirdPartyIntegration_GetID_Call

+ type ThirdPartyIntegration_GetUsers_Call struct

+ func (_c *ThirdPartyIntegration_GetUsers_Call) Return(users []core.User) *ThirdPartyIntegration_GetUsers_Call

+ func (_c *ThirdPartyIntegration_GetUsers_Call) Run(run func(org models.Org)) *ThirdPartyIntegration_GetUsers_Call

+ func (_c *ThirdPartyIntegration_GetUsers_Call) RunAndReturn(run func(org models.Org) []core.User) *ThirdPartyIntegration_GetUsers_Call

+ type ThirdPartyIntegration_HandleEvent_Call struct

+ func (_c *ThirdPartyIntegration_HandleEvent_Call) Return(err error) *ThirdPartyIntegration_HandleEvent_Call

+ func (_c *ThirdPartyIntegration_HandleEvent_Call) Run(run func(event any)) *ThirdPartyIntegration_HandleEvent_Call

+ func (_c *ThirdPartyIntegration_HandleEvent_Call) RunAndReturn(run func(event any) error) *ThirdPartyIntegration_HandleEvent_Call

+ type ThirdPartyIntegration_HandleWebhook_Call struct

+ func (_c *ThirdPartyIntegration_HandleWebhook_Call) Return(err error) *ThirdPartyIntegration_HandleWebhook_Call

+ func (_c *ThirdPartyIntegration_HandleWebhook_Call) Run(run func(ctx core.Context)) *ThirdPartyIntegration_HandleWebhook_Call

+ func (_c *ThirdPartyIntegration_HandleWebhook_Call) RunAndReturn(run func(ctx core.Context) error) *ThirdPartyIntegration_HandleWebhook_Call

+ type ThirdPartyIntegration_HasAccessToExternalEntityProvider_Call struct

+ func (_c *ThirdPartyIntegration_HasAccessToExternalEntityProvider_Call) Return(b bool, err error) *ThirdPartyIntegration_HasAccessToExternalEntityProvider_Call

+ func (_c *ThirdPartyIntegration_HasAccessToExternalEntityProvider_Call) Run(run func(ctx core.Context, externalEntityProviderID string)) *ThirdPartyIntegration_HasAccessToExternalEntityProvider_Call

+ func (_c *ThirdPartyIntegration_HasAccessToExternalEntityProvider_Call) RunAndReturn(run func(ctx core.Context, externalEntityProviderID string) (bool, error)) *ThirdPartyIntegration_HasAccessToExternalEntityProvider_Call

+ type ThirdPartyIntegration_ListGroups_Call struct

+ func (_c *ThirdPartyIntegration_ListGroups_Call) Return(projects []models.Project, roles []core.Role, err error) *ThirdPartyIntegration_ListGroups_Call

+ func (_c *ThirdPartyIntegration_ListGroups_Call) Run(run func(ctx context.Context, userID string, providerID string)) *ThirdPartyIntegration_ListGroups_Call

+ func (_c *ThirdPartyIntegration_ListGroups_Call) RunAndReturn(...) *ThirdPartyIntegration_ListGroups_Call

+ type ThirdPartyIntegration_ListOrgs_Call struct

+ func (_c *ThirdPartyIntegration_ListOrgs_Call) Return(orgs []models.Org, err error) *ThirdPartyIntegration_ListOrgs_Call

+ func (_c *ThirdPartyIntegration_ListOrgs_Call) Run(run func(ctx core.Context)) *ThirdPartyIntegration_ListOrgs_Call

+ func (_c *ThirdPartyIntegration_ListOrgs_Call) RunAndReturn(run func(ctx core.Context) ([]models.Org, error)) *ThirdPartyIntegration_ListOrgs_Call

+ type ThirdPartyIntegration_ListProjects_Call struct

+ func (_c *ThirdPartyIntegration_ListProjects_Call) Return(assets []models.Asset, roles []core.Role, err error) *ThirdPartyIntegration_ListProjects_Call

+ func (_c *ThirdPartyIntegration_ListProjects_Call) Run(...) *ThirdPartyIntegration_ListProjects_Call

+ func (_c *ThirdPartyIntegration_ListProjects_Call) RunAndReturn(...) *ThirdPartyIntegration_ListProjects_Call

+ type ThirdPartyIntegration_ListRepositories_Call struct

+ func (_c *ThirdPartyIntegration_ListRepositories_Call) Return(repositorys []core.Repository, err error) *ThirdPartyIntegration_ListRepositories_Call

+ func (_c *ThirdPartyIntegration_ListRepositories_Call) Run(run func(ctx core.Context)) *ThirdPartyIntegration_ListRepositories_Call

+ func (_c *ThirdPartyIntegration_ListRepositories_Call) RunAndReturn(run func(ctx core.Context) ([]core.Repository, error)) *ThirdPartyIntegration_ListRepositories_Call

+ type ThirdPartyIntegration_UpdateIssue_Call struct

+ func (_c *ThirdPartyIntegration_UpdateIssue_Call) Return(err error) *ThirdPartyIntegration_UpdateIssue_Call

+ func (_c *ThirdPartyIntegration_UpdateIssue_Call) Run(run func(ctx context.Context, asset models.Asset, vuln models.Vuln)) *ThirdPartyIntegration_UpdateIssue_Call

+ func (_c *ThirdPartyIntegration_UpdateIssue_Call) RunAndReturn(run func(ctx context.Context, asset models.Asset, vuln models.Vuln) error) *ThirdPartyIntegration_UpdateIssue_Call

+ type ThirdPartyIntegration_WantsToHandleWebhook_Call struct

+ func (_c *ThirdPartyIntegration_WantsToHandleWebhook_Call) Return(b bool) *ThirdPartyIntegration_WantsToHandleWebhook_Call

+ func (_c *ThirdPartyIntegration_WantsToHandleWebhook_Call) Run(run func(ctx core.Context)) *ThirdPartyIntegration_WantsToHandleWebhook_Call

+ func (_c *ThirdPartyIntegration_WantsToHandleWebhook_Call) RunAndReturn(run func(ctx core.Context) bool) *ThirdPartyIntegration_WantsToHandleWebhook_Call

+ type Verifier struct

+ func NewVerifier(t interface{ ... }) *Verifier

+ func (_m *Verifier) EXPECT() *Verifier_Expecter

+ func (_mock *Verifier) VerifyRequestSignature(req *http.Request) (string, string, error)

+ type Verifier_Expecter struct

+ func (_e *Verifier_Expecter) VerifyRequestSignature(req interface{}) *Verifier_VerifyRequestSignature_Call

+ type Verifier_VerifyRequestSignature_Call struct

+ func (_c *Verifier_VerifyRequestSignature_Call) Return(s string, s1 string, err error) *Verifier_VerifyRequestSignature_Call

+ func (_c *Verifier_VerifyRequestSignature_Call) Run(run func(req *http.Request)) *Verifier_VerifyRequestSignature_Call

+ func (_c *Verifier_VerifyRequestSignature_Call) RunAndReturn(run func(req *http.Request) (string, string, error)) *Verifier_VerifyRequestSignature_Call

+ type VulnEventRepository struct

+ func NewVulnEventRepository(t interface{ ... }) *VulnEventRepository

+ func (_m *VulnEventRepository) EXPECT() *VulnEventRepository_Expecter

+ func (_mock *VulnEventRepository) ReadAssetEventsByVulnID(vulnID string, vulnType models.VulnType) ([]models.VulnEventDetail, error)

+ func (_mock *VulnEventRepository) ReadEventsByAssetIDAndAssetVersionName(assetID uuid.UUID, assetVersionName string, pageInfo core.PageInfo, ...) (core.Paged[models.VulnEventDetail], error)

+ func (_mock *VulnEventRepository) Save(db core.DB, event *models.VulnEvent) error

+ func (_mock *VulnEventRepository) SaveBatch(db core.DB, events []models.VulnEvent) error

+ type VulnEventRepository_Expecter struct

+ func (_e *VulnEventRepository_Expecter) ReadAssetEventsByVulnID(vulnID interface{}, vulnType interface{}) *VulnEventRepository_ReadAssetEventsByVulnID_Call

+ func (_e *VulnEventRepository_Expecter) ReadEventsByAssetIDAndAssetVersionName(assetID interface{}, assetVersionName interface{}, pageInfo interface{}, ...) *VulnEventRepository_ReadEventsByAssetIDAndAssetVersionName_Call

+ func (_e *VulnEventRepository_Expecter) Save(db interface{}, event interface{}) *VulnEventRepository_Save_Call

+ func (_e *VulnEventRepository_Expecter) SaveBatch(db interface{}, events interface{}) *VulnEventRepository_SaveBatch_Call

+ type VulnEventRepository_ReadAssetEventsByVulnID_Call struct

+ func (_c *VulnEventRepository_ReadAssetEventsByVulnID_Call) Return(vulnEventDetails []models.VulnEventDetail, err error) *VulnEventRepository_ReadAssetEventsByVulnID_Call

+ func (_c *VulnEventRepository_ReadAssetEventsByVulnID_Call) Run(run func(vulnID string, vulnType models.VulnType)) *VulnEventRepository_ReadAssetEventsByVulnID_Call

+ func (_c *VulnEventRepository_ReadAssetEventsByVulnID_Call) RunAndReturn(...) *VulnEventRepository_ReadAssetEventsByVulnID_Call

+ type VulnEventRepository_ReadEventsByAssetIDAndAssetVersionName_Call struct

+ func (_c *VulnEventRepository_ReadEventsByAssetIDAndAssetVersionName_Call) Return(paged core.Paged[models.VulnEventDetail], err error) *VulnEventRepository_ReadEventsByAssetIDAndAssetVersionName_Call

+ func (_c *VulnEventRepository_ReadEventsByAssetIDAndAssetVersionName_Call) Run(...) *VulnEventRepository_ReadEventsByAssetIDAndAssetVersionName_Call

+ func (_c *VulnEventRepository_ReadEventsByAssetIDAndAssetVersionName_Call) RunAndReturn(...) *VulnEventRepository_ReadEventsByAssetIDAndAssetVersionName_Call

+ type VulnEventRepository_SaveBatch_Call struct

+ func (_c *VulnEventRepository_SaveBatch_Call) Return(err error) *VulnEventRepository_SaveBatch_Call

+ func (_c *VulnEventRepository_SaveBatch_Call) Run(run func(db core.DB, events []models.VulnEvent)) *VulnEventRepository_SaveBatch_Call

+ func (_c *VulnEventRepository_SaveBatch_Call) RunAndReturn(run func(db core.DB, events []models.VulnEvent) error) *VulnEventRepository_SaveBatch_Call

+ type VulnEventRepository_Save_Call struct

+ func (_c *VulnEventRepository_Save_Call) Return(err error) *VulnEventRepository_Save_Call

+ func (_c *VulnEventRepository_Save_Call) Run(run func(db core.DB, event *models.VulnEvent)) *VulnEventRepository_Save_Call

+ func (_c *VulnEventRepository_Save_Call) RunAndReturn(run func(db core.DB, event *models.VulnEvent) error) *VulnEventRepository_Save_Call

+ type VulnRepository struct

+ func NewVulnRepository(t interface{ ... }) *VulnRepository

+ func (_m *VulnRepository) EXPECT() *VulnRepository_Expecter

+ func (_mock *VulnRepository) ApplyAndSave(tx core.DB, dependencyVuln models.Vuln, vulnEvent *models.VulnEvent) error

+ func (_mock *VulnRepository) FindByTicketID(tx core.DB, ticketID string) (models.Vuln, error)

+ func (_mock *VulnRepository) GetOrgFromVuln(vuln models.Vuln) (models.Org, error)

+ func (_mock *VulnRepository) Save(db core.DB, vuln *models.Vuln) error

+ func (_mock *VulnRepository) Transaction(fn func(tx core.DB) error) error

+ type VulnRepository_ApplyAndSave_Call struct

+ func (_c *VulnRepository_ApplyAndSave_Call) Return(err error) *VulnRepository_ApplyAndSave_Call

+ func (_c *VulnRepository_ApplyAndSave_Call) Run(run func(tx core.DB, dependencyVuln models.Vuln, vulnEvent *models.VulnEvent)) *VulnRepository_ApplyAndSave_Call

+ func (_c *VulnRepository_ApplyAndSave_Call) RunAndReturn(...) *VulnRepository_ApplyAndSave_Call

+ type VulnRepository_Expecter struct

+ func (_e *VulnRepository_Expecter) ApplyAndSave(tx interface{}, dependencyVuln interface{}, vulnEvent interface{}) *VulnRepository_ApplyAndSave_Call

+ func (_e *VulnRepository_Expecter) FindByTicketID(tx interface{}, ticketID interface{}) *VulnRepository_FindByTicketID_Call

+ func (_e *VulnRepository_Expecter) GetOrgFromVuln(vuln interface{}) *VulnRepository_GetOrgFromVuln_Call

+ func (_e *VulnRepository_Expecter) Save(db interface{}, vuln interface{}) *VulnRepository_Save_Call

+ func (_e *VulnRepository_Expecter) Transaction(fn interface{}) *VulnRepository_Transaction_Call

+ type VulnRepository_FindByTicketID_Call struct

+ func (_c *VulnRepository_FindByTicketID_Call) Return(vuln models.Vuln, err error) *VulnRepository_FindByTicketID_Call

+ func (_c *VulnRepository_FindByTicketID_Call) Run(run func(tx core.DB, ticketID string)) *VulnRepository_FindByTicketID_Call

+ func (_c *VulnRepository_FindByTicketID_Call) RunAndReturn(run func(tx core.DB, ticketID string) (models.Vuln, error)) *VulnRepository_FindByTicketID_Call

+ type VulnRepository_GetOrgFromVuln_Call struct

+ func (_c *VulnRepository_GetOrgFromVuln_Call) Return(org models.Org, err error) *VulnRepository_GetOrgFromVuln_Call

+ func (_c *VulnRepository_GetOrgFromVuln_Call) Run(run func(vuln models.Vuln)) *VulnRepository_GetOrgFromVuln_Call

+ func (_c *VulnRepository_GetOrgFromVuln_Call) RunAndReturn(run func(vuln models.Vuln) (models.Org, error)) *VulnRepository_GetOrgFromVuln_Call

+ type VulnRepository_Save_Call struct

+ func (_c *VulnRepository_Save_Call) Return(err error) *VulnRepository_Save_Call

+ func (_c *VulnRepository_Save_Call) Run(run func(db core.DB, vuln *models.Vuln)) *VulnRepository_Save_Call

+ func (_c *VulnRepository_Save_Call) RunAndReturn(run func(db core.DB, vuln *models.Vuln) error) *VulnRepository_Save_Call

+ type VulnRepository_Transaction_Call struct

+ func (_c *VulnRepository_Transaction_Call) Return(err error) *VulnRepository_Transaction_Call

+ func (_c *VulnRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *VulnRepository_Transaction_Call

+ func (_c *VulnRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *VulnRepository_Transaction_Call

+ type WebhookIntegrationRepository struct

+ func NewWebhookIntegrationRepository(t interface{ ... }) *WebhookIntegrationRepository

+ func (_m *WebhookIntegrationRepository) EXPECT() *WebhookIntegrationRepository_Expecter

+ func (_mock *WebhookIntegrationRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_mock *WebhookIntegrationRepository) FindByOrgIDAndProjectID(orgID uuid.UUID, projectID uuid.UUID) ([]models.WebhookIntegration, error)

+ func (_mock *WebhookIntegrationRepository) GetClientByIntegrationID(integrationID uuid.UUID) (models.WebhookIntegration, error)

+ func (_mock *WebhookIntegrationRepository) GetProjectWebhooks(orgID uuid.UUID, projectID uuid.UUID) ([]models.WebhookIntegration, error)

+ func (_mock *WebhookIntegrationRepository) Read(id uuid.UUID) (models.WebhookIntegration, error)

+ func (_mock *WebhookIntegrationRepository) Save(tx core.DB, model *models.WebhookIntegration) error

+ type WebhookIntegrationRepository_Delete_Call struct

+ func (_c *WebhookIntegrationRepository_Delete_Call) Return(err error) *WebhookIntegrationRepository_Delete_Call

+ func (_c *WebhookIntegrationRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *WebhookIntegrationRepository_Delete_Call

+ func (_c *WebhookIntegrationRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id uuid.UUID) error) *WebhookIntegrationRepository_Delete_Call

+ type WebhookIntegrationRepository_Expecter struct

+ func (_e *WebhookIntegrationRepository_Expecter) Delete(tx interface{}, id interface{}) *WebhookIntegrationRepository_Delete_Call

+ func (_e *WebhookIntegrationRepository_Expecter) FindByOrgIDAndProjectID(orgID interface{}, projectID interface{}) *WebhookIntegrationRepository_FindByOrgIDAndProjectID_Call

+ func (_e *WebhookIntegrationRepository_Expecter) GetClientByIntegrationID(integrationID interface{}) *WebhookIntegrationRepository_GetClientByIntegrationID_Call

+ func (_e *WebhookIntegrationRepository_Expecter) GetProjectWebhooks(orgID interface{}, projectID interface{}) *WebhookIntegrationRepository_GetProjectWebhooks_Call

+ func (_e *WebhookIntegrationRepository_Expecter) Read(id interface{}) *WebhookIntegrationRepository_Read_Call

+ func (_e *WebhookIntegrationRepository_Expecter) Save(tx interface{}, model interface{}) *WebhookIntegrationRepository_Save_Call

+ type WebhookIntegrationRepository_FindByOrgIDAndProjectID_Call struct

+ func (_c *WebhookIntegrationRepository_FindByOrgIDAndProjectID_Call) Return(webhookIntegrations []models.WebhookIntegration, err error) *WebhookIntegrationRepository_FindByOrgIDAndProjectID_Call

+ func (_c *WebhookIntegrationRepository_FindByOrgIDAndProjectID_Call) Run(run func(orgID uuid.UUID, projectID uuid.UUID)) *WebhookIntegrationRepository_FindByOrgIDAndProjectID_Call

+ func (_c *WebhookIntegrationRepository_FindByOrgIDAndProjectID_Call) RunAndReturn(...) *WebhookIntegrationRepository_FindByOrgIDAndProjectID_Call

+ type WebhookIntegrationRepository_GetClientByIntegrationID_Call struct

+ func (_c *WebhookIntegrationRepository_GetClientByIntegrationID_Call) Return(webhookIntegration models.WebhookIntegration, err error) *WebhookIntegrationRepository_GetClientByIntegrationID_Call

+ func (_c *WebhookIntegrationRepository_GetClientByIntegrationID_Call) Run(run func(integrationID uuid.UUID)) *WebhookIntegrationRepository_GetClientByIntegrationID_Call

+ func (_c *WebhookIntegrationRepository_GetClientByIntegrationID_Call) RunAndReturn(run func(integrationID uuid.UUID) (models.WebhookIntegration, error)) *WebhookIntegrationRepository_GetClientByIntegrationID_Call

+ type WebhookIntegrationRepository_GetProjectWebhooks_Call struct

+ func (_c *WebhookIntegrationRepository_GetProjectWebhooks_Call) Return(webhookIntegrations []models.WebhookIntegration, err error) *WebhookIntegrationRepository_GetProjectWebhooks_Call

+ func (_c *WebhookIntegrationRepository_GetProjectWebhooks_Call) Run(run func(orgID uuid.UUID, projectID uuid.UUID)) *WebhookIntegrationRepository_GetProjectWebhooks_Call

+ func (_c *WebhookIntegrationRepository_GetProjectWebhooks_Call) RunAndReturn(...) *WebhookIntegrationRepository_GetProjectWebhooks_Call

+ type WebhookIntegrationRepository_Read_Call struct

+ func (_c *WebhookIntegrationRepository_Read_Call) Return(webhookIntegration models.WebhookIntegration, err error) *WebhookIntegrationRepository_Read_Call

+ func (_c *WebhookIntegrationRepository_Read_Call) Run(run func(id uuid.UUID)) *WebhookIntegrationRepository_Read_Call

+ func (_c *WebhookIntegrationRepository_Read_Call) RunAndReturn(run func(id uuid.UUID) (models.WebhookIntegration, error)) *WebhookIntegrationRepository_Read_Call

+ type WebhookIntegrationRepository_Save_Call struct

+ func (_c *WebhookIntegrationRepository_Save_Call) Return(err error) *WebhookIntegrationRepository_Save_Call

+ func (_c *WebhookIntegrationRepository_Save_Call) Run(run func(tx core.DB, model *models.WebhookIntegration)) *WebhookIntegrationRepository_Save_Call

+ func (_c *WebhookIntegrationRepository_Save_Call) RunAndReturn(run func(tx core.DB, model *models.WebhookIntegration) error) *WebhookIntegrationRepository_Save_Call

v0.16.1-test.3

Sep 16, 2025

v0.16.1-test.2

Sep 16, 2025

v0.16.1-test.1

Sep 16, 2025

v0.5.15

Dec 27, 2024

Changes in this version

type AccesscontrolAccessControl

+ func (_m *AccesscontrolAccessControl) InheritProjectRolesAcrossProjects(roleWhichGetsPermissions accesscontrol.ProjectRole, ...) error

type AccesscontrolAccessControl_Expecter

+ func (_e *AccesscontrolAccessControl_Expecter) InheritProjectRolesAcrossProjects(roleWhichGetsPermissions interface{}, roleWhichProvidesPermissions interface{}) *AccesscontrolAccessControl_InheritProjectRolesAcrossProjects_Call

+ type AccesscontrolAccessControl_InheritProjectRolesAcrossProjects_Call struct

+ func (_c *AccesscontrolAccessControl_InheritProjectRolesAcrossProjects_Call) Return(_a0 error) *AccesscontrolAccessControl_InheritProjectRolesAcrossProjects_Call

+ func (_c *AccesscontrolAccessControl_InheritProjectRolesAcrossProjects_Call) Run(run func(roleWhichGetsPermissions accesscontrol.ProjectRole, ...)) *AccesscontrolAccessControl_InheritProjectRolesAcrossProjects_Call

+ func (_c *AccesscontrolAccessControl_InheritProjectRolesAcrossProjects_Call) RunAndReturn(run func(accesscontrol.ProjectRole, accesscontrol.ProjectRole) error) *AccesscontrolAccessControl_InheritProjectRolesAcrossProjects_Call

type AssetRepository

+ func (_m *AssetRepository) Activate(tx *gorm.DB, id uuid.UUID) error

+ func (_m *AssetRepository) ReadBySlugUnscoped(projectID uuid.UUID, slug string) (models.Asset, error)

+ type AssetRepository_Activate_Call struct

+ func (_c *AssetRepository_Activate_Call) Return(_a0 error) *AssetRepository_Activate_Call

+ func (_c *AssetRepository_Activate_Call) Run(run func(tx *gorm.DB, id uuid.UUID)) *AssetRepository_Activate_Call

+ func (_c *AssetRepository_Activate_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *AssetRepository_Activate_Call

type AssetRepository_Expecter

+ func (_e *AssetRepository_Expecter) Activate(tx interface{}, id interface{}) *AssetRepository_Activate_Call

+ func (_e *AssetRepository_Expecter) ReadBySlugUnscoped(projectID interface{}, slug interface{}) *AssetRepository_ReadBySlugUnscoped_Call

+ type AssetRepository_ReadBySlugUnscoped_Call struct

+ func (_c *AssetRepository_ReadBySlugUnscoped_Call) Return(_a0 models.Asset, _a1 error) *AssetRepository_ReadBySlugUnscoped_Call

+ func (_c *AssetRepository_ReadBySlugUnscoped_Call) Run(run func(projectID uuid.UUID, slug string)) *AssetRepository_ReadBySlugUnscoped_Call

+ func (_c *AssetRepository_ReadBySlugUnscoped_Call) RunAndReturn(run func(uuid.UUID, string) (models.Asset, error)) *AssetRepository_ReadBySlugUnscoped_Call

+ type AssetSupplyChainRepository struct

+ func NewAssetSupplyChainRepository(t interface{ ... }) *AssetSupplyChainRepository

+ func (_m *AssetSupplyChainRepository) EXPECT() *AssetSupplyChainRepository_Expecter

+ func (_m *AssetSupplyChainRepository) PercentageOfVerifiedSupplyChains(assetID uuid.UUID) (float64, error)

+ type AssetSupplyChainRepository_Expecter struct

+ func (_e *AssetSupplyChainRepository_Expecter) PercentageOfVerifiedSupplyChains(assetID interface{}) *AssetSupplyChainRepository_PercentageOfVerifiedSupplyChains_Call

+ type AssetSupplyChainRepository_PercentageOfVerifiedSupplyChains_Call struct

+ func (_c *AssetSupplyChainRepository_PercentageOfVerifiedSupplyChains_Call) Return(_a0 float64, _a1 error) *AssetSupplyChainRepository_PercentageOfVerifiedSupplyChains_Call

+ func (_c *AssetSupplyChainRepository_PercentageOfVerifiedSupplyChains_Call) Run(run func(assetID uuid.UUID)) *AssetSupplyChainRepository_PercentageOfVerifiedSupplyChains_Call

+ func (_c *AssetSupplyChainRepository_PercentageOfVerifiedSupplyChains_Call) RunAndReturn(run func(uuid.UUID) (float64, error)) *AssetSupplyChainRepository_PercentageOfVerifiedSupplyChains_Call

type FlawRepository

+ func (_m *FlawRepository) Activate(tx *gorm.DB, id string) error

+ type FlawRepository_Activate_Call struct

+ func (_c *FlawRepository_Activate_Call) Return(_a0 error) *FlawRepository_Activate_Call

+ func (_c *FlawRepository_Activate_Call) Run(run func(tx *gorm.DB, id string)) *FlawRepository_Activate_Call

+ func (_c *FlawRepository_Activate_Call) RunAndReturn(run func(*gorm.DB, string) error) *FlawRepository_Activate_Call

type FlawRepository_Expecter

+ func (_e *FlawRepository_Expecter) Activate(tx interface{}, id interface{}) *FlawRepository_Activate_Call

type IntotoInTotoVerifierService

+ func (_m *IntotoInTotoVerifierService) VerifySupplyChain(supplyChainID string) (bool, error)

+ func (_m *IntotoInTotoVerifierService) VerifySupplyChainWithOutputDigest(supplyChainID string, digest string) (bool, error)

type IntotoInTotoVerifierService_Expecter

+ func (_e *IntotoInTotoVerifierService_Expecter) VerifySupplyChain(supplyChainID interface{}) *IntotoInTotoVerifierService_VerifySupplyChain_Call

+ func (_e *IntotoInTotoVerifierService_Expecter) VerifySupplyChainWithOutputDigest(supplyChainID interface{}, digest interface{}) *IntotoInTotoVerifierService_VerifySupplyChainWithOutputDigest_Call

+ type IntotoInTotoVerifierService_VerifySupplyChainWithOutputDigest_Call struct

+ func (_c *IntotoInTotoVerifierService_VerifySupplyChainWithOutputDigest_Call) Return(_a0 bool, _a1 error) *IntotoInTotoVerifierService_VerifySupplyChainWithOutputDigest_Call

+ func (_c *IntotoInTotoVerifierService_VerifySupplyChainWithOutputDigest_Call) Run(run func(supplyChainID string, digest string)) *IntotoInTotoVerifierService_VerifySupplyChainWithOutputDigest_Call

+ func (_c *IntotoInTotoVerifierService_VerifySupplyChainWithOutputDigest_Call) RunAndReturn(run func(string, string) (bool, error)) *IntotoInTotoVerifierService_VerifySupplyChainWithOutputDigest_Call

+ type IntotoInTotoVerifierService_VerifySupplyChain_Call struct

+ func (_c *IntotoInTotoVerifierService_VerifySupplyChain_Call) Return(_a0 bool, _a1 error) *IntotoInTotoVerifierService_VerifySupplyChain_Call

+ func (_c *IntotoInTotoVerifierService_VerifySupplyChain_Call) Run(run func(supplyChainID string)) *IntotoInTotoVerifierService_VerifySupplyChain_Call

+ func (_c *IntotoInTotoVerifierService_VerifySupplyChain_Call) RunAndReturn(run func(string) (bool, error)) *IntotoInTotoVerifierService_VerifySupplyChain_Call

type IntotoRepository

+ func (_m *IntotoRepository) Activate(tx *gorm.DB, id uuid.UUID) error

+ type IntotoRepository_Activate_Call struct

+ func (_c *IntotoRepository_Activate_Call) Return(_a0 error) *IntotoRepository_Activate_Call

+ func (_c *IntotoRepository_Activate_Call) Run(run func(tx *gorm.DB, id uuid.UUID)) *IntotoRepository_Activate_Call

+ func (_c *IntotoRepository_Activate_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *IntotoRepository_Activate_Call

type IntotoRepository_Expecter

+ func (_e *IntotoRepository_Expecter) Activate(tx interface{}, id interface{}) *IntotoRepository_Activate_Call

type OrgRepository

+ func (_m *OrgRepository) Activate(tx *gorm.DB, id uuid.UUID) error

+ type OrgRepository_Activate_Call struct

+ func (_c *OrgRepository_Activate_Call) Return(_a0 error) *OrgRepository_Activate_Call

+ func (_c *OrgRepository_Activate_Call) Run(run func(tx *gorm.DB, id uuid.UUID)) *OrgRepository_Activate_Call

+ func (_c *OrgRepository_Activate_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *OrgRepository_Activate_Call

type OrgRepository_Expecter

+ func (_e *OrgRepository_Expecter) Activate(tx interface{}, id interface{}) *OrgRepository_Activate_Call

type PatRepository

+ func (_m *PatRepository) Activate(tx *gorm.DB, id uuid.UUID) error

+ type PatRepository_Activate_Call struct

+ func (_c *PatRepository_Activate_Call) Return(_a0 error) *PatRepository_Activate_Call

+ func (_c *PatRepository_Activate_Call) Run(run func(tx *gorm.DB, id uuid.UUID)) *PatRepository_Activate_Call

+ func (_c *PatRepository_Activate_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *PatRepository_Activate_Call

type PatRepository_Expecter

+ func (_e *PatRepository_Expecter) Activate(tx interface{}, id interface{}) *PatRepository_Activate_Call

type ProjectProjectRepository

+ func (_m *ProjectProjectRepository) Activate(tx *gorm.DB, projectID uuid.UUID) error

+ func (_m *ProjectProjectRepository) ReadBySlugUnscoped(organizationId uuid.UUID, slug string) (models.Project, error)

+ type ProjectProjectRepository_Activate_Call struct

+ func (_c *ProjectProjectRepository_Activate_Call) Return(_a0 error) *ProjectProjectRepository_Activate_Call

+ func (_c *ProjectProjectRepository_Activate_Call) Run(run func(tx *gorm.DB, projectID uuid.UUID)) *ProjectProjectRepository_Activate_Call

+ func (_c *ProjectProjectRepository_Activate_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *ProjectProjectRepository_Activate_Call

type ProjectProjectRepository_Expecter

+ func (_e *ProjectProjectRepository_Expecter) Activate(tx interface{}, projectID interface{}) *ProjectProjectRepository_Activate_Call

+ func (_e *ProjectProjectRepository_Expecter) ReadBySlugUnscoped(organizationId interface{}, slug interface{}) *ProjectProjectRepository_ReadBySlugUnscoped_Call

+ type ProjectProjectRepository_ReadBySlugUnscoped_Call struct

+ func (_c *ProjectProjectRepository_ReadBySlugUnscoped_Call) Return(_a0 models.Project, _a1 error) *ProjectProjectRepository_ReadBySlugUnscoped_Call

+ func (_c *ProjectProjectRepository_ReadBySlugUnscoped_Call) Run(run func(organizationId uuid.UUID, slug string)) *ProjectProjectRepository_ReadBySlugUnscoped_Call

+ func (_c *ProjectProjectRepository_ReadBySlugUnscoped_Call) RunAndReturn(run func(uuid.UUID, string) (models.Project, error)) *ProjectProjectRepository_ReadBySlugUnscoped_Call

type VulndbCveRepository

+ func (_m *VulndbCveRepository) Activate(tx *gorm.DB, id string) error

+ type VulndbCveRepository_Activate_Call struct

+ func (_c *VulndbCveRepository_Activate_Call) Return(_a0 error) *VulndbCveRepository_Activate_Call

+ func (_c *VulndbCveRepository_Activate_Call) Run(run func(tx *gorm.DB, id string)) *VulndbCveRepository_Activate_Call

+ func (_c *VulndbCveRepository_Activate_Call) RunAndReturn(run func(*gorm.DB, string) error) *VulndbCveRepository_Activate_Call

type VulndbCveRepository_Expecter

+ func (_e *VulndbCveRepository_Expecter) Activate(tx interface{}, id interface{}) *VulndbCveRepository_Activate_Call

type VulndbCvesRepository

+ func (_m *VulndbCvesRepository) Activate(tx *gorm.DB, id string) error

+ type VulndbCvesRepository_Activate_Call struct

+ func (_c *VulndbCvesRepository_Activate_Call) Return(_a0 error) *VulndbCvesRepository_Activate_Call

+ func (_c *VulndbCvesRepository_Activate_Call) Run(run func(tx *gorm.DB, id string)) *VulndbCvesRepository_Activate_Call

+ func (_c *VulndbCvesRepository_Activate_Call) RunAndReturn(run func(*gorm.DB, string) error) *VulndbCvesRepository_Activate_Call

type VulndbCvesRepository_Expecter

+ func (_e *VulndbCvesRepository_Expecter) Activate(tx interface{}, id interface{}) *VulndbCvesRepository_Activate_Call

v0.5.14

Dec 24, 2024

Changes in this version

+ type AccesscontrolAccessControl struct

+ func NewAccesscontrolAccessControl(t interface{ ... }) *AccesscontrolAccessControl

+ func (_m *AccesscontrolAccessControl) AllowRole(role string, object string, action []accesscontrol.Action) error

+ func (_m *AccesscontrolAccessControl) AllowRoleInProject(project string, role string, object string, action []accesscontrol.Action) error

+ func (_m *AccesscontrolAccessControl) EXPECT() *AccesscontrolAccessControl_Expecter

+ func (_m *AccesscontrolAccessControl) GetAllMembersOfOrganization() ([]string, error)

+ func (_m *AccesscontrolAccessControl) GetAllMembersOfProject(projectID string) ([]string, error)

+ func (_m *AccesscontrolAccessControl) GetAllProjectsForUser(user string) []string

+ func (_m *AccesscontrolAccessControl) GetAllRoles(user string) []string

+ func (_m *AccesscontrolAccessControl) GetDomainRole(user string) (string, error)

+ func (_m *AccesscontrolAccessControl) GetOwnerOfOrganization() (string, error)

+ func (_m *AccesscontrolAccessControl) GetProjectRole(user string, project string) (string, error)

+ func (_m *AccesscontrolAccessControl) GrantRole(subject string, role string) error

+ func (_m *AccesscontrolAccessControl) GrantRoleInProject(subject string, role string, project string) error

+ func (_m *AccesscontrolAccessControl) HasAccess(subject string) bool

+ func (_m *AccesscontrolAccessControl) InheritProjectRole(roleWhichGetsPermissions string, roleWhichProvidesPermissions string, ...) error

+ func (_m *AccesscontrolAccessControl) InheritRole(roleWhichGetsPermissions string, roleWhichProvidesPermissions string) error

+ func (_m *AccesscontrolAccessControl) IsAllowed(subject string, object string, action accesscontrol.Action) (bool, error)

+ func (_m *AccesscontrolAccessControl) IsAllowedInProject(project string, user string, object string, action accesscontrol.Action) (bool, error)

+ func (_m *AccesscontrolAccessControl) LinkDomainAndProjectRole(domainRoleWhichGetsPermission string, ...) error

+ func (_m *AccesscontrolAccessControl) RevokeRole(subject string, role string) error

+ func (_m *AccesscontrolAccessControl) RevokeRoleInProject(subject string, role string, project string) error

+ type AccesscontrolAccessControl_AllowRoleInProject_Call struct

+ func (_c *AccesscontrolAccessControl_AllowRoleInProject_Call) Return(_a0 error) *AccesscontrolAccessControl_AllowRoleInProject_Call

+ func (_c *AccesscontrolAccessControl_AllowRoleInProject_Call) Run(...) *AccesscontrolAccessControl_AllowRoleInProject_Call

+ func (_c *AccesscontrolAccessControl_AllowRoleInProject_Call) RunAndReturn(run func(string, string, string, []accesscontrol.Action) error) *AccesscontrolAccessControl_AllowRoleInProject_Call

+ type AccesscontrolAccessControl_AllowRole_Call struct

+ func (_c *AccesscontrolAccessControl_AllowRole_Call) Return(_a0 error) *AccesscontrolAccessControl_AllowRole_Call

+ func (_c *AccesscontrolAccessControl_AllowRole_Call) Run(run func(role string, object string, action []accesscontrol.Action)) *AccesscontrolAccessControl_AllowRole_Call

+ func (_c *AccesscontrolAccessControl_AllowRole_Call) RunAndReturn(run func(string, string, []accesscontrol.Action) error) *AccesscontrolAccessControl_AllowRole_Call

+ type AccesscontrolAccessControl_Expecter struct

+ func (_e *AccesscontrolAccessControl_Expecter) AllowRole(role interface{}, object interface{}, action interface{}) *AccesscontrolAccessControl_AllowRole_Call

+ func (_e *AccesscontrolAccessControl_Expecter) AllowRoleInProject(project interface{}, role interface{}, object interface{}, action interface{}) *AccesscontrolAccessControl_AllowRoleInProject_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GetAllMembersOfOrganization() *AccesscontrolAccessControl_GetAllMembersOfOrganization_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GetAllMembersOfProject(projectID interface{}) *AccesscontrolAccessControl_GetAllMembersOfProject_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GetAllProjectsForUser(user interface{}) *AccesscontrolAccessControl_GetAllProjectsForUser_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GetAllRoles(user interface{}) *AccesscontrolAccessControl_GetAllRoles_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GetDomainRole(user interface{}) *AccesscontrolAccessControl_GetDomainRole_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GetOwnerOfOrganization() *AccesscontrolAccessControl_GetOwnerOfOrganization_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GetProjectRole(user interface{}, project interface{}) *AccesscontrolAccessControl_GetProjectRole_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GrantRole(subject interface{}, role interface{}) *AccesscontrolAccessControl_GrantRole_Call

+ func (_e *AccesscontrolAccessControl_Expecter) GrantRoleInProject(subject interface{}, role interface{}, project interface{}) *AccesscontrolAccessControl_GrantRoleInProject_Call

+ func (_e *AccesscontrolAccessControl_Expecter) HasAccess(subject interface{}) *AccesscontrolAccessControl_HasAccess_Call

+ func (_e *AccesscontrolAccessControl_Expecter) InheritProjectRole(roleWhichGetsPermissions interface{}, roleWhichProvidesPermissions interface{}, ...) *AccesscontrolAccessControl_InheritProjectRole_Call

+ func (_e *AccesscontrolAccessControl_Expecter) InheritRole(roleWhichGetsPermissions interface{}, roleWhichProvidesPermissions interface{}) *AccesscontrolAccessControl_InheritRole_Call

+ func (_e *AccesscontrolAccessControl_Expecter) IsAllowed(subject interface{}, object interface{}, action interface{}) *AccesscontrolAccessControl_IsAllowed_Call

+ func (_e *AccesscontrolAccessControl_Expecter) IsAllowedInProject(project interface{}, user interface{}, object interface{}, action interface{}) *AccesscontrolAccessControl_IsAllowedInProject_Call

+ func (_e *AccesscontrolAccessControl_Expecter) LinkDomainAndProjectRole(domainRoleWhichGetsPermission interface{}, ...) *AccesscontrolAccessControl_LinkDomainAndProjectRole_Call

+ func (_e *AccesscontrolAccessControl_Expecter) RevokeRole(subject interface{}, role interface{}) *AccesscontrolAccessControl_RevokeRole_Call

+ func (_e *AccesscontrolAccessControl_Expecter) RevokeRoleInProject(subject interface{}, role interface{}, project interface{}) *AccesscontrolAccessControl_RevokeRoleInProject_Call

+ type AccesscontrolAccessControl_GetAllMembersOfOrganization_Call struct

+ func (_c *AccesscontrolAccessControl_GetAllMembersOfOrganization_Call) Return(_a0 []string, _a1 error) *AccesscontrolAccessControl_GetAllMembersOfOrganization_Call

+ func (_c *AccesscontrolAccessControl_GetAllMembersOfOrganization_Call) Run(run func()) *AccesscontrolAccessControl_GetAllMembersOfOrganization_Call

+ func (_c *AccesscontrolAccessControl_GetAllMembersOfOrganization_Call) RunAndReturn(run func() ([]string, error)) *AccesscontrolAccessControl_GetAllMembersOfOrganization_Call

+ type AccesscontrolAccessControl_GetAllMembersOfProject_Call struct

+ func (_c *AccesscontrolAccessControl_GetAllMembersOfProject_Call) Return(_a0 []string, _a1 error) *AccesscontrolAccessControl_GetAllMembersOfProject_Call

+ func (_c *AccesscontrolAccessControl_GetAllMembersOfProject_Call) Run(run func(projectID string)) *AccesscontrolAccessControl_GetAllMembersOfProject_Call

+ func (_c *AccesscontrolAccessControl_GetAllMembersOfProject_Call) RunAndReturn(run func(string) ([]string, error)) *AccesscontrolAccessControl_GetAllMembersOfProject_Call

+ type AccesscontrolAccessControl_GetAllProjectsForUser_Call struct

+ func (_c *AccesscontrolAccessControl_GetAllProjectsForUser_Call) Return(_a0 []string) *AccesscontrolAccessControl_GetAllProjectsForUser_Call

+ func (_c *AccesscontrolAccessControl_GetAllProjectsForUser_Call) Run(run func(user string)) *AccesscontrolAccessControl_GetAllProjectsForUser_Call

+ func (_c *AccesscontrolAccessControl_GetAllProjectsForUser_Call) RunAndReturn(run func(string) []string) *AccesscontrolAccessControl_GetAllProjectsForUser_Call

+ type AccesscontrolAccessControl_GetAllRoles_Call struct

+ func (_c *AccesscontrolAccessControl_GetAllRoles_Call) Return(_a0 []string) *AccesscontrolAccessControl_GetAllRoles_Call

+ func (_c *AccesscontrolAccessControl_GetAllRoles_Call) Run(run func(user string)) *AccesscontrolAccessControl_GetAllRoles_Call

+ func (_c *AccesscontrolAccessControl_GetAllRoles_Call) RunAndReturn(run func(string) []string) *AccesscontrolAccessControl_GetAllRoles_Call

+ type AccesscontrolAccessControl_GetDomainRole_Call struct

+ func (_c *AccesscontrolAccessControl_GetDomainRole_Call) Return(_a0 string, _a1 error) *AccesscontrolAccessControl_GetDomainRole_Call

+ func (_c *AccesscontrolAccessControl_GetDomainRole_Call) Run(run func(user string)) *AccesscontrolAccessControl_GetDomainRole_Call

+ func (_c *AccesscontrolAccessControl_GetDomainRole_Call) RunAndReturn(run func(string) (string, error)) *AccesscontrolAccessControl_GetDomainRole_Call

+ type AccesscontrolAccessControl_GetOwnerOfOrganization_Call struct

+ func (_c *AccesscontrolAccessControl_GetOwnerOfOrganization_Call) Return(_a0 string, _a1 error) *AccesscontrolAccessControl_GetOwnerOfOrganization_Call

+ func (_c *AccesscontrolAccessControl_GetOwnerOfOrganization_Call) Run(run func()) *AccesscontrolAccessControl_GetOwnerOfOrganization_Call

+ func (_c *AccesscontrolAccessControl_GetOwnerOfOrganization_Call) RunAndReturn(run func() (string, error)) *AccesscontrolAccessControl_GetOwnerOfOrganization_Call

+ type AccesscontrolAccessControl_GetProjectRole_Call struct

+ func (_c *AccesscontrolAccessControl_GetProjectRole_Call) Return(_a0 string, _a1 error) *AccesscontrolAccessControl_GetProjectRole_Call

+ func (_c *AccesscontrolAccessControl_GetProjectRole_Call) Run(run func(user string, project string)) *AccesscontrolAccessControl_GetProjectRole_Call

+ func (_c *AccesscontrolAccessControl_GetProjectRole_Call) RunAndReturn(run func(string, string) (string, error)) *AccesscontrolAccessControl_GetProjectRole_Call

+ type AccesscontrolAccessControl_GrantRoleInProject_Call struct

+ func (_c *AccesscontrolAccessControl_GrantRoleInProject_Call) Return(_a0 error) *AccesscontrolAccessControl_GrantRoleInProject_Call

+ func (_c *AccesscontrolAccessControl_GrantRoleInProject_Call) Run(run func(subject string, role string, project string)) *AccesscontrolAccessControl_GrantRoleInProject_Call

+ func (_c *AccesscontrolAccessControl_GrantRoleInProject_Call) RunAndReturn(run func(string, string, string) error) *AccesscontrolAccessControl_GrantRoleInProject_Call

+ type AccesscontrolAccessControl_GrantRole_Call struct

+ func (_c *AccesscontrolAccessControl_GrantRole_Call) Return(_a0 error) *AccesscontrolAccessControl_GrantRole_Call

+ func (_c *AccesscontrolAccessControl_GrantRole_Call) Run(run func(subject string, role string)) *AccesscontrolAccessControl_GrantRole_Call

+ func (_c *AccesscontrolAccessControl_GrantRole_Call) RunAndReturn(run func(string, string) error) *AccesscontrolAccessControl_GrantRole_Call

+ type AccesscontrolAccessControl_HasAccess_Call struct

+ func (_c *AccesscontrolAccessControl_HasAccess_Call) Return(_a0 bool) *AccesscontrolAccessControl_HasAccess_Call

+ func (_c *AccesscontrolAccessControl_HasAccess_Call) Run(run func(subject string)) *AccesscontrolAccessControl_HasAccess_Call

+ func (_c *AccesscontrolAccessControl_HasAccess_Call) RunAndReturn(run func(string) bool) *AccesscontrolAccessControl_HasAccess_Call

+ type AccesscontrolAccessControl_InheritProjectRole_Call struct

+ func (_c *AccesscontrolAccessControl_InheritProjectRole_Call) Return(_a0 error) *AccesscontrolAccessControl_InheritProjectRole_Call

+ func (_c *AccesscontrolAccessControl_InheritProjectRole_Call) Run(...) *AccesscontrolAccessControl_InheritProjectRole_Call

+ func (_c *AccesscontrolAccessControl_InheritProjectRole_Call) RunAndReturn(run func(string, string, string) error) *AccesscontrolAccessControl_InheritProjectRole_Call

+ type AccesscontrolAccessControl_InheritRole_Call struct

+ func (_c *AccesscontrolAccessControl_InheritRole_Call) Return(_a0 error) *AccesscontrolAccessControl_InheritRole_Call

+ func (_c *AccesscontrolAccessControl_InheritRole_Call) Run(run func(roleWhichGetsPermissions string, roleWhichProvidesPermissions string)) *AccesscontrolAccessControl_InheritRole_Call

+ func (_c *AccesscontrolAccessControl_InheritRole_Call) RunAndReturn(run func(string, string) error) *AccesscontrolAccessControl_InheritRole_Call

+ type AccesscontrolAccessControl_IsAllowedInProject_Call struct

+ func (_c *AccesscontrolAccessControl_IsAllowedInProject_Call) Return(_a0 bool, _a1 error) *AccesscontrolAccessControl_IsAllowedInProject_Call

+ func (_c *AccesscontrolAccessControl_IsAllowedInProject_Call) Run(...) *AccesscontrolAccessControl_IsAllowedInProject_Call

+ func (_c *AccesscontrolAccessControl_IsAllowedInProject_Call) RunAndReturn(run func(string, string, string, accesscontrol.Action) (bool, error)) *AccesscontrolAccessControl_IsAllowedInProject_Call

+ type AccesscontrolAccessControl_IsAllowed_Call struct

+ func (_c *AccesscontrolAccessControl_IsAllowed_Call) Return(_a0 bool, _a1 error) *AccesscontrolAccessControl_IsAllowed_Call

+ func (_c *AccesscontrolAccessControl_IsAllowed_Call) Run(run func(subject string, object string, action accesscontrol.Action)) *AccesscontrolAccessControl_IsAllowed_Call

+ func (_c *AccesscontrolAccessControl_IsAllowed_Call) RunAndReturn(run func(string, string, accesscontrol.Action) (bool, error)) *AccesscontrolAccessControl_IsAllowed_Call

+ type AccesscontrolAccessControl_LinkDomainAndProjectRole_Call struct

+ func (_c *AccesscontrolAccessControl_LinkDomainAndProjectRole_Call) Return(_a0 error) *AccesscontrolAccessControl_LinkDomainAndProjectRole_Call

+ func (_c *AccesscontrolAccessControl_LinkDomainAndProjectRole_Call) Run(run func(domainRoleWhichGetsPermission string, ...)) *AccesscontrolAccessControl_LinkDomainAndProjectRole_Call

+ func (_c *AccesscontrolAccessControl_LinkDomainAndProjectRole_Call) RunAndReturn(run func(string, string, string) error) *AccesscontrolAccessControl_LinkDomainAndProjectRole_Call

+ type AccesscontrolAccessControl_RevokeRoleInProject_Call struct

+ func (_c *AccesscontrolAccessControl_RevokeRoleInProject_Call) Return(_a0 error) *AccesscontrolAccessControl_RevokeRoleInProject_Call

+ func (_c *AccesscontrolAccessControl_RevokeRoleInProject_Call) Run(run func(subject string, role string, project string)) *AccesscontrolAccessControl_RevokeRoleInProject_Call

+ func (_c *AccesscontrolAccessControl_RevokeRoleInProject_Call) RunAndReturn(run func(string, string, string) error) *AccesscontrolAccessControl_RevokeRoleInProject_Call

+ type AccesscontrolAccessControl_RevokeRole_Call struct

+ func (_c *AccesscontrolAccessControl_RevokeRole_Call) Return(_a0 error) *AccesscontrolAccessControl_RevokeRole_Call

+ func (_c *AccesscontrolAccessControl_RevokeRole_Call) Run(run func(subject string, role string)) *AccesscontrolAccessControl_RevokeRole_Call

+ func (_c *AccesscontrolAccessControl_RevokeRole_Call) RunAndReturn(run func(string, string) error) *AccesscontrolAccessControl_RevokeRole_Call

+ type AccesscontrolRBACProvider struct

+ func NewAccesscontrolRBACProvider(t interface{ ... }) *AccesscontrolRBACProvider

+ func (_m *AccesscontrolRBACProvider) DomainsOfUser(user string) ([]string, error)

+ func (_m *AccesscontrolRBACProvider) EXPECT() *AccesscontrolRBACProvider_Expecter

+ func (_m *AccesscontrolRBACProvider) GetDomainRBAC(domain string) accesscontrol.AccessControl

+ type AccesscontrolRBACProvider_DomainsOfUser_Call struct

+ func (_c *AccesscontrolRBACProvider_DomainsOfUser_Call) Return(_a0 []string, _a1 error) *AccesscontrolRBACProvider_DomainsOfUser_Call

+ func (_c *AccesscontrolRBACProvider_DomainsOfUser_Call) Run(run func(user string)) *AccesscontrolRBACProvider_DomainsOfUser_Call

+ func (_c *AccesscontrolRBACProvider_DomainsOfUser_Call) RunAndReturn(run func(string) ([]string, error)) *AccesscontrolRBACProvider_DomainsOfUser_Call

+ type AccesscontrolRBACProvider_Expecter struct

+ func (_e *AccesscontrolRBACProvider_Expecter) DomainsOfUser(user interface{}) *AccesscontrolRBACProvider_DomainsOfUser_Call

+ func (_e *AccesscontrolRBACProvider_Expecter) GetDomainRBAC(domain interface{}) *AccesscontrolRBACProvider_GetDomainRBAC_Call

+ type AccesscontrolRBACProvider_GetDomainRBAC_Call struct

+ func (_c *AccesscontrolRBACProvider_GetDomainRBAC_Call) Return(_a0 accesscontrol.AccessControl) *AccesscontrolRBACProvider_GetDomainRBAC_Call

+ func (_c *AccesscontrolRBACProvider_GetDomainRBAC_Call) Run(run func(domain string)) *AccesscontrolRBACProvider_GetDomainRBAC_Call

+ func (_c *AccesscontrolRBACProvider_GetDomainRBAC_Call) RunAndReturn(run func(string) accesscontrol.AccessControl) *AccesscontrolRBACProvider_GetDomainRBAC_Call

+ type ApiAssetRepository struct

+ func NewApiAssetRepository(t interface{ ... }) *ApiAssetRepository

+ func (_m *ApiAssetRepository) EXPECT() *ApiAssetRepository_Expecter

+ func (_m *ApiAssetRepository) ReadBySlug(projectID uuid.UUID, slug string) (models.Asset, error)

+ type ApiAssetRepository_Expecter struct

+ func (_e *ApiAssetRepository_Expecter) ReadBySlug(projectID interface{}, slug interface{}) *ApiAssetRepository_ReadBySlug_Call

+ type ApiAssetRepository_ReadBySlug_Call struct

+ func (_c *ApiAssetRepository_ReadBySlug_Call) Return(_a0 models.Asset, _a1 error) *ApiAssetRepository_ReadBySlug_Call

+ func (_c *ApiAssetRepository_ReadBySlug_Call) Run(run func(projectID uuid.UUID, slug string)) *ApiAssetRepository_ReadBySlug_Call

+ func (_c *ApiAssetRepository_ReadBySlug_Call) RunAndReturn(run func(uuid.UUID, string) (models.Asset, error)) *ApiAssetRepository_ReadBySlug_Call

+ type ApiOrgRepository struct

+ func NewApiOrgRepository(t interface{ ... }) *ApiOrgRepository

+ func (_m *ApiOrgRepository) EXPECT() *ApiOrgRepository_Expecter

+ func (_m *ApiOrgRepository) ReadBySlug(slugOrId string) (models.Org, error)

+ type ApiOrgRepository_Expecter struct

+ func (_e *ApiOrgRepository_Expecter) ReadBySlug(slugOrId interface{}) *ApiOrgRepository_ReadBySlug_Call

+ type ApiOrgRepository_ReadBySlug_Call struct

+ func (_c *ApiOrgRepository_ReadBySlug_Call) Return(_a0 models.Org, _a1 error) *ApiOrgRepository_ReadBySlug_Call

+ func (_c *ApiOrgRepository_ReadBySlug_Call) Run(run func(slugOrId string)) *ApiOrgRepository_ReadBySlug_Call

+ func (_c *ApiOrgRepository_ReadBySlug_Call) RunAndReturn(run func(string) (models.Org, error)) *ApiOrgRepository_ReadBySlug_Call

+ type ApiProjectRepository struct

+ func NewApiProjectRepository(t interface{ ... }) *ApiProjectRepository

+ func (_m *ApiProjectRepository) EXPECT() *ApiProjectRepository_Expecter

+ func (_m *ApiProjectRepository) ReadBySlug(organizationID uuid.UUID, slug string) (models.Project, error)

+ type ApiProjectRepository_Expecter struct

+ func (_e *ApiProjectRepository_Expecter) ReadBySlug(organizationID interface{}, slug interface{}) *ApiProjectRepository_ReadBySlug_Call

+ type ApiProjectRepository_ReadBySlug_Call struct

+ func (_c *ApiProjectRepository_ReadBySlug_Call) Return(_a0 models.Project, _a1 error) *ApiProjectRepository_ReadBySlug_Call

+ func (_c *ApiProjectRepository_ReadBySlug_Call) Run(run func(organizationID uuid.UUID, slug string)) *ApiProjectRepository_ReadBySlug_Call

+ func (_c *ApiProjectRepository_ReadBySlug_Call) RunAndReturn(run func(uuid.UUID, string) (models.Project, error)) *ApiProjectRepository_ReadBySlug_Call

type AssetAssetComponentsLoader

+ func (_m *AssetAssetComponentsLoader) LoadComponents(tx core.DB, _a1 models.Asset, scanType string, version string) ([]models.ComponentDependency, error)

type AssetAssetComponentsLoader_Expecter

+ func (_e *AssetAssetComponentsLoader_Expecter) LoadComponents(tx interface{}, _a1 interface{}, scanType interface{}, version interface{}) *AssetAssetComponentsLoader_LoadComponents_Call

+ type AssetAssetComponentsLoader_LoadComponents_Call struct

+ func (_c *AssetAssetComponentsLoader_LoadComponents_Call) Return(_a0 []models.ComponentDependency, _a1 error) *AssetAssetComponentsLoader_LoadComponents_Call

+ func (_c *AssetAssetComponentsLoader_LoadComponents_Call) Run(run func(tx core.DB, _a1 models.Asset, scanType string, version string)) *AssetAssetComponentsLoader_LoadComponents_Call

+ func (_c *AssetAssetComponentsLoader_LoadComponents_Call) RunAndReturn(...) *AssetAssetComponentsLoader_LoadComponents_Call

type AssetAssetRepository

+ func (_m *AssetAssetRepository) Transaction(txFunc func(core.DB) error) error

type AssetAssetRepository_Expecter

+ func (_e *AssetAssetRepository_Expecter) Transaction(txFunc interface{}) *AssetAssetRepository_Transaction_Call

+ type AssetAssetRepository_Transaction_Call struct

+ func (_c *AssetAssetRepository_Transaction_Call) Return(_a0 error) *AssetAssetRepository_Transaction_Call

+ func (_c *AssetAssetRepository_Transaction_Call) Run(run func(txFunc func(core.DB) error)) *AssetAssetRepository_Transaction_Call

+ func (_c *AssetAssetRepository_Transaction_Call) RunAndReturn(run func(func(core.DB) error) error) *AssetAssetRepository_Transaction_Call

type AssetAssetService

+ func (_m *AssetAssetService) BuildVeX(_a0 models.Asset, version string, orgName string, ...) *cyclonedx.BOM

+ type AssetAssetService_BuildVeX_Call struct

+ func (_c *AssetAssetService_BuildVeX_Call) Return(_a0 *cyclonedx.BOM) *AssetAssetService_BuildVeX_Call

+ func (_c *AssetAssetService_BuildVeX_Call) Run(run func(_a0 models.Asset, version string, orgName string, ...)) *AssetAssetService_BuildVeX_Call

+ func (_c *AssetAssetService_BuildVeX_Call) RunAndReturn(...) *AssetAssetService_BuildVeX_Call

type AssetAssetService_Expecter

+ func (_e *AssetAssetService_Expecter) BuildVeX(_a0 interface{}, version interface{}, orgName interface{}, ...) *AssetAssetService_BuildVeX_Call

type AssetComponentRepository

+ func (_m *AssetComponentRepository) LoadComponents(tx core.DB, _a1 models.Asset, scanType string, version string) ([]models.ComponentDependency, error)

type AssetComponentRepository_Expecter

+ func (_e *AssetComponentRepository_Expecter) LoadComponents(tx interface{}, _a1 interface{}, scanType interface{}, version interface{}) *AssetComponentRepository_LoadComponents_Call

+ type AssetComponentRepository_LoadComponents_Call struct

+ func (_c *AssetComponentRepository_LoadComponents_Call) Return(_a0 []models.ComponentDependency, _a1 error) *AssetComponentRepository_LoadComponents_Call

+ func (_c *AssetComponentRepository_LoadComponents_Call) Run(run func(tx core.DB, _a1 models.Asset, scanType string, version string)) *AssetComponentRepository_LoadComponents_Call

+ func (_c *AssetComponentRepository_LoadComponents_Call) RunAndReturn(...) *AssetComponentRepository_LoadComponents_Call

+ type CoreIntegrationAggregate struct

+ func NewCoreIntegrationAggregate(t interface{ ... }) *CoreIntegrationAggregate

+ func (_m *CoreIntegrationAggregate) EXPECT() *CoreIntegrationAggregate_Expecter

+ func (_m *CoreIntegrationAggregate) GetID() core.IntegrationID

+ func (_m *CoreIntegrationAggregate) GetIntegration(id core.IntegrationID) core.ThirdPartyIntegration

+ func (_m *CoreIntegrationAggregate) GetUsers(org models.Org) []core.User

+ func (_m *CoreIntegrationAggregate) HandleEvent(event any) error

+ func (_m *CoreIntegrationAggregate) HandleWebhook(ctx core.Context) error

+ func (_m *CoreIntegrationAggregate) IntegrationEnabled(ctx core.Context) bool

+ func (_m *CoreIntegrationAggregate) ListRepositories(ctx core.Context) ([]core.Repository, error)

+ func (_m *CoreIntegrationAggregate) WantsToHandleWebhook(ctx core.Context) bool

+ type CoreIntegrationAggregate_Expecter struct

+ func (_e *CoreIntegrationAggregate_Expecter) GetID() *CoreIntegrationAggregate_GetID_Call

+ func (_e *CoreIntegrationAggregate_Expecter) GetIntegration(id interface{}) *CoreIntegrationAggregate_GetIntegration_Call

+ func (_e *CoreIntegrationAggregate_Expecter) GetUsers(org interface{}) *CoreIntegrationAggregate_GetUsers_Call

+ func (_e *CoreIntegrationAggregate_Expecter) HandleEvent(event interface{}) *CoreIntegrationAggregate_HandleEvent_Call

+ func (_e *CoreIntegrationAggregate_Expecter) HandleWebhook(ctx interface{}) *CoreIntegrationAggregate_HandleWebhook_Call

+ func (_e *CoreIntegrationAggregate_Expecter) IntegrationEnabled(ctx interface{}) *CoreIntegrationAggregate_IntegrationEnabled_Call

+ func (_e *CoreIntegrationAggregate_Expecter) ListRepositories(ctx interface{}) *CoreIntegrationAggregate_ListRepositories_Call

+ func (_e *CoreIntegrationAggregate_Expecter) WantsToHandleWebhook(ctx interface{}) *CoreIntegrationAggregate_WantsToHandleWebhook_Call

+ type CoreIntegrationAggregate_GetID_Call struct

+ func (_c *CoreIntegrationAggregate_GetID_Call) Return(_a0 core.IntegrationID) *CoreIntegrationAggregate_GetID_Call

+ func (_c *CoreIntegrationAggregate_GetID_Call) Run(run func()) *CoreIntegrationAggregate_GetID_Call

+ func (_c *CoreIntegrationAggregate_GetID_Call) RunAndReturn(run func() core.IntegrationID) *CoreIntegrationAggregate_GetID_Call

+ type CoreIntegrationAggregate_GetIntegration_Call struct

+ func (_c *CoreIntegrationAggregate_GetIntegration_Call) Return(_a0 core.ThirdPartyIntegration) *CoreIntegrationAggregate_GetIntegration_Call

+ func (_c *CoreIntegrationAggregate_GetIntegration_Call) Run(run func(id core.IntegrationID)) *CoreIntegrationAggregate_GetIntegration_Call

+ func (_c *CoreIntegrationAggregate_GetIntegration_Call) RunAndReturn(run func(core.IntegrationID) core.ThirdPartyIntegration) *CoreIntegrationAggregate_GetIntegration_Call

+ type CoreIntegrationAggregate_GetUsers_Call struct

+ func (_c *CoreIntegrationAggregate_GetUsers_Call) Return(_a0 []core.User) *CoreIntegrationAggregate_GetUsers_Call

+ func (_c *CoreIntegrationAggregate_GetUsers_Call) Run(run func(org models.Org)) *CoreIntegrationAggregate_GetUsers_Call

+ func (_c *CoreIntegrationAggregate_GetUsers_Call) RunAndReturn(run func(models.Org) []core.User) *CoreIntegrationAggregate_GetUsers_Call

+ type CoreIntegrationAggregate_HandleEvent_Call struct

+ func (_c *CoreIntegrationAggregate_HandleEvent_Call) Return(_a0 error) *CoreIntegrationAggregate_HandleEvent_Call

+ func (_c *CoreIntegrationAggregate_HandleEvent_Call) Run(run func(event any)) *CoreIntegrationAggregate_HandleEvent_Call

+ func (_c *CoreIntegrationAggregate_HandleEvent_Call) RunAndReturn(run func(any) error) *CoreIntegrationAggregate_HandleEvent_Call

+ type CoreIntegrationAggregate_HandleWebhook_Call struct

+ func (_c *CoreIntegrationAggregate_HandleWebhook_Call) Return(_a0 error) *CoreIntegrationAggregate_HandleWebhook_Call

+ func (_c *CoreIntegrationAggregate_HandleWebhook_Call) Run(run func(ctx core.Context)) *CoreIntegrationAggregate_HandleWebhook_Call

+ func (_c *CoreIntegrationAggregate_HandleWebhook_Call) RunAndReturn(run func(core.Context) error) *CoreIntegrationAggregate_HandleWebhook_Call

+ type CoreIntegrationAggregate_IntegrationEnabled_Call struct

+ func (_c *CoreIntegrationAggregate_IntegrationEnabled_Call) Return(_a0 bool) *CoreIntegrationAggregate_IntegrationEnabled_Call

+ func (_c *CoreIntegrationAggregate_IntegrationEnabled_Call) Run(run func(ctx core.Context)) *CoreIntegrationAggregate_IntegrationEnabled_Call

+ func (_c *CoreIntegrationAggregate_IntegrationEnabled_Call) RunAndReturn(run func(core.Context) bool) *CoreIntegrationAggregate_IntegrationEnabled_Call

+ type CoreIntegrationAggregate_ListRepositories_Call struct

+ func (_c *CoreIntegrationAggregate_ListRepositories_Call) Return(_a0 []core.Repository, _a1 error) *CoreIntegrationAggregate_ListRepositories_Call

+ func (_c *CoreIntegrationAggregate_ListRepositories_Call) Run(run func(ctx core.Context)) *CoreIntegrationAggregate_ListRepositories_Call

+ func (_c *CoreIntegrationAggregate_ListRepositories_Call) RunAndReturn(run func(core.Context) ([]core.Repository, error)) *CoreIntegrationAggregate_ListRepositories_Call

+ type CoreIntegrationAggregate_WantsToHandleWebhook_Call struct

+ func (_c *CoreIntegrationAggregate_WantsToHandleWebhook_Call) Return(_a0 bool) *CoreIntegrationAggregate_WantsToHandleWebhook_Call

+ func (_c *CoreIntegrationAggregate_WantsToHandleWebhook_Call) Run(run func(ctx core.Context)) *CoreIntegrationAggregate_WantsToHandleWebhook_Call

+ func (_c *CoreIntegrationAggregate_WantsToHandleWebhook_Call) RunAndReturn(run func(core.Context) bool) *CoreIntegrationAggregate_WantsToHandleWebhook_Call

type CoreThirdPartyIntegration

+ func (_m *CoreThirdPartyIntegration) GetID() core.IntegrationID

+ func (_m *CoreThirdPartyIntegration) GetUsers(org models.Org) []core.User

type CoreThirdPartyIntegration_Expecter

+ func (_e *CoreThirdPartyIntegration_Expecter) GetID() *CoreThirdPartyIntegration_GetID_Call

+ func (_e *CoreThirdPartyIntegration_Expecter) GetUsers(org interface{}) *CoreThirdPartyIntegration_GetUsers_Call

+ type CoreThirdPartyIntegration_GetID_Call struct

+ func (_c *CoreThirdPartyIntegration_GetID_Call) Return(_a0 core.IntegrationID) *CoreThirdPartyIntegration_GetID_Call

+ func (_c *CoreThirdPartyIntegration_GetID_Call) Run(run func()) *CoreThirdPartyIntegration_GetID_Call

+ func (_c *CoreThirdPartyIntegration_GetID_Call) RunAndReturn(run func() core.IntegrationID) *CoreThirdPartyIntegration_GetID_Call

+ type CoreThirdPartyIntegration_GetUsers_Call struct

+ func (_c *CoreThirdPartyIntegration_GetUsers_Call) Return(_a0 []core.User) *CoreThirdPartyIntegration_GetUsers_Call

+ func (_c *CoreThirdPartyIntegration_GetUsers_Call) Run(run func(org models.Org)) *CoreThirdPartyIntegration_GetUsers_Call

+ func (_c *CoreThirdPartyIntegration_GetUsers_Call) RunAndReturn(run func(models.Org) []core.User) *CoreThirdPartyIntegration_GetUsers_Call

+ type FlawLeaderElector struct

+ func NewFlawLeaderElector(t interface{ ... }) *FlawLeaderElector

+ func (_m *FlawLeaderElector) EXPECT() *FlawLeaderElector_Expecter

+ func (_m *FlawLeaderElector) IfLeader(ctx context.Context, fn func() error)

+ type FlawLeaderElector_Expecter struct

+ func (_e *FlawLeaderElector_Expecter) IfLeader(ctx interface{}, fn interface{}) *FlawLeaderElector_IfLeader_Call

+ type FlawLeaderElector_IfLeader_Call struct

+ func (_c *FlawLeaderElector_IfLeader_Call) Return() *FlawLeaderElector_IfLeader_Call

+ func (_c *FlawLeaderElector_IfLeader_Call) Run(run func(ctx context.Context, fn func() error)) *FlawLeaderElector_IfLeader_Call

+ func (_c *FlawLeaderElector_IfLeader_Call) RunAndReturn(run func(context.Context, func() error)) *FlawLeaderElector_IfLeader_Call

+ type FlawProjectService struct

+ func NewFlawProjectService(t interface{ ... }) *FlawProjectService

+ func (_m *FlawProjectService) EXPECT() *FlawProjectService_Expecter

+ func (_m *FlawProjectService) ListAllowedProjects(c core.Context) ([]models.Project, error)

+ type FlawProjectService_Expecter struct

+ func (_e *FlawProjectService_Expecter) ListAllowedProjects(c interface{}) *FlawProjectService_ListAllowedProjects_Call

+ type FlawProjectService_ListAllowedProjects_Call struct

+ func (_c *FlawProjectService_ListAllowedProjects_Call) Return(_a0 []models.Project, _a1 error) *FlawProjectService_ListAllowedProjects_Call

+ func (_c *FlawProjectService_ListAllowedProjects_Call) Run(run func(c core.Context)) *FlawProjectService_ListAllowedProjects_Call

+ func (_c *FlawProjectService_ListAllowedProjects_Call) RunAndReturn(run func(core.Context) ([]models.Project, error)) *FlawProjectService_ListAllowedProjects_Call

type FlawRepository

+ func (_m *FlawRepository) GetFlawsByAssetIdPagedAndFlat(tx core.DB, assetId uuid.UUID, pageInfo core.PageInfo, search string, ...) (core.Paged[models.Flaw], error)

+ func (_m *FlawRepository) GetFlawsByOrgIdPaged(tx core.DB, userAllowedProjectIds []string, pageInfo core.PageInfo, ...) (core.Paged[models.Flaw], error)

+ func (_m *FlawRepository) GetFlawsByProjectIdPaged(tx core.DB, projectID uuid.UUID, pageInfo core.PageInfo, search string, ...) (core.Paged[models.Flaw], error)

type FlawRepository_Expecter

+ func (_e *FlawRepository_Expecter) GetFlawsByAssetIdPagedAndFlat(tx interface{}, assetId interface{}, pageInfo interface{}, search interface{}, ...) *FlawRepository_GetFlawsByAssetIdPagedAndFlat_Call

+ func (_e *FlawRepository_Expecter) GetFlawsByOrgIdPaged(tx interface{}, userAllowedProjectIds interface{}, pageInfo interface{}, ...) *FlawRepository_GetFlawsByOrgIdPaged_Call

+ func (_e *FlawRepository_Expecter) GetFlawsByProjectIdPaged(tx interface{}, projectID interface{}, pageInfo interface{}, ...) *FlawRepository_GetFlawsByProjectIdPaged_Call

+ type FlawRepository_GetFlawsByAssetIdPagedAndFlat_Call struct

+ func (_c *FlawRepository_GetFlawsByAssetIdPagedAndFlat_Call) Return(_a0 core.Paged[models.Flaw], _a1 error) *FlawRepository_GetFlawsByAssetIdPagedAndFlat_Call

+ func (_c *FlawRepository_GetFlawsByAssetIdPagedAndFlat_Call) Run(...) *FlawRepository_GetFlawsByAssetIdPagedAndFlat_Call

+ func (_c *FlawRepository_GetFlawsByAssetIdPagedAndFlat_Call) RunAndReturn(...) *FlawRepository_GetFlawsByAssetIdPagedAndFlat_Call

+ type FlawRepository_GetFlawsByOrgIdPaged_Call struct

+ func (_c *FlawRepository_GetFlawsByOrgIdPaged_Call) Return(_a0 core.Paged[models.Flaw], _a1 error) *FlawRepository_GetFlawsByOrgIdPaged_Call

+ func (_c *FlawRepository_GetFlawsByOrgIdPaged_Call) Run(...) *FlawRepository_GetFlawsByOrgIdPaged_Call

+ func (_c *FlawRepository_GetFlawsByOrgIdPaged_Call) RunAndReturn(...) *FlawRepository_GetFlawsByOrgIdPaged_Call

+ type FlawRepository_GetFlawsByProjectIdPaged_Call struct

+ func (_c *FlawRepository_GetFlawsByProjectIdPaged_Call) Return(_a0 core.Paged[models.Flaw], _a1 error) *FlawRepository_GetFlawsByProjectIdPaged_Call

+ func (_c *FlawRepository_GetFlawsByProjectIdPaged_Call) Run(...) *FlawRepository_GetFlawsByProjectIdPaged_Call

+ func (_c *FlawRepository_GetFlawsByProjectIdPaged_Call) RunAndReturn(...) *FlawRepository_GetFlawsByProjectIdPaged_Call

+ type IntegrationsAssetRepository struct

+ func NewIntegrationsAssetRepository(t interface{ ... }) *IntegrationsAssetRepository

+ func (_m *IntegrationsAssetRepository) EXPECT() *IntegrationsAssetRepository_Expecter

+ func (_m *IntegrationsAssetRepository) Read(id uuid.UUID) (models.Asset, error)

+ type IntegrationsAssetRepository_Expecter struct

+ func (_e *IntegrationsAssetRepository_Expecter) Read(id interface{}) *IntegrationsAssetRepository_Read_Call

+ type IntegrationsAssetRepository_Read_Call struct

+ func (_c *IntegrationsAssetRepository_Read_Call) Return(_a0 models.Asset, _a1 error) *IntegrationsAssetRepository_Read_Call

+ func (_c *IntegrationsAssetRepository_Read_Call) Run(run func(id uuid.UUID)) *IntegrationsAssetRepository_Read_Call

+ func (_c *IntegrationsAssetRepository_Read_Call) RunAndReturn(run func(uuid.UUID) (models.Asset, error)) *IntegrationsAssetRepository_Read_Call

+ type IntegrationsExternalUserRepository struct

+ func NewIntegrationsExternalUserRepository(t interface{ ... }) *IntegrationsExternalUserRepository

+ func (_m *IntegrationsExternalUserRepository) EXPECT() *IntegrationsExternalUserRepository_Expecter

+ func (_m *IntegrationsExternalUserRepository) FindByOrgID(tx core.DB, orgID uuid.UUID) ([]models.ExternalUser, error)

+ func (_m *IntegrationsExternalUserRepository) GetDB(tx core.DB) core.DB

+ func (_m *IntegrationsExternalUserRepository) Save(db core.DB, user *models.ExternalUser) error

+ type IntegrationsExternalUserRepository_Expecter struct

+ func (_e *IntegrationsExternalUserRepository_Expecter) FindByOrgID(tx interface{}, orgID interface{}) *IntegrationsExternalUserRepository_FindByOrgID_Call

+ func (_e *IntegrationsExternalUserRepository_Expecter) GetDB(tx interface{}) *IntegrationsExternalUserRepository_GetDB_Call

+ func (_e *IntegrationsExternalUserRepository_Expecter) Save(db interface{}, user interface{}) *IntegrationsExternalUserRepository_Save_Call

+ type IntegrationsExternalUserRepository_FindByOrgID_Call struct

+ func (_c *IntegrationsExternalUserRepository_FindByOrgID_Call) Return(_a0 []models.ExternalUser, _a1 error) *IntegrationsExternalUserRepository_FindByOrgID_Call

+ func (_c *IntegrationsExternalUserRepository_FindByOrgID_Call) Run(run func(tx core.DB, orgID uuid.UUID)) *IntegrationsExternalUserRepository_FindByOrgID_Call

+ func (_c *IntegrationsExternalUserRepository_FindByOrgID_Call) RunAndReturn(run func(core.DB, uuid.UUID) ([]models.ExternalUser, error)) *IntegrationsExternalUserRepository_FindByOrgID_Call

+ type IntegrationsExternalUserRepository_GetDB_Call struct

+ func (_c *IntegrationsExternalUserRepository_GetDB_Call) Return(_a0 core.DB) *IntegrationsExternalUserRepository_GetDB_Call

+ func (_c *IntegrationsExternalUserRepository_GetDB_Call) Run(run func(tx core.DB)) *IntegrationsExternalUserRepository_GetDB_Call

+ func (_c *IntegrationsExternalUserRepository_GetDB_Call) RunAndReturn(run func(core.DB) core.DB) *IntegrationsExternalUserRepository_GetDB_Call

+ type IntegrationsExternalUserRepository_Save_Call struct

+ func (_c *IntegrationsExternalUserRepository_Save_Call) Return(_a0 error) *IntegrationsExternalUserRepository_Save_Call

+ func (_c *IntegrationsExternalUserRepository_Save_Call) Run(run func(db core.DB, user *models.ExternalUser)) *IntegrationsExternalUserRepository_Save_Call

+ func (_c *IntegrationsExternalUserRepository_Save_Call) RunAndReturn(run func(core.DB, *models.ExternalUser) error) *IntegrationsExternalUserRepository_Save_Call

+ type IntegrationsFlawEventRepository struct

+ func NewIntegrationsFlawEventRepository(t interface{ ... }) *IntegrationsFlawEventRepository

+ func (_m *IntegrationsFlawEventRepository) EXPECT() *IntegrationsFlawEventRepository_Expecter

+ func (_m *IntegrationsFlawEventRepository) Save(db core.DB, event *models.FlawEvent) error

+ type IntegrationsFlawEventRepository_Expecter struct

+ func (_e *IntegrationsFlawEventRepository_Expecter) Save(db interface{}, event interface{}) *IntegrationsFlawEventRepository_Save_Call

+ type IntegrationsFlawEventRepository_Save_Call struct

+ func (_c *IntegrationsFlawEventRepository_Save_Call) Return(_a0 error) *IntegrationsFlawEventRepository_Save_Call

+ func (_c *IntegrationsFlawEventRepository_Save_Call) Run(run func(db core.DB, event *models.FlawEvent)) *IntegrationsFlawEventRepository_Save_Call

+ func (_c *IntegrationsFlawEventRepository_Save_Call) RunAndReturn(run func(core.DB, *models.FlawEvent) error) *IntegrationsFlawEventRepository_Save_Call

+ type IntegrationsFlawRepository struct

+ func NewIntegrationsFlawRepository(t interface{ ... }) *IntegrationsFlawRepository

+ func (_m *IntegrationsFlawRepository) EXPECT() *IntegrationsFlawRepository_Expecter

+ func (_m *IntegrationsFlawRepository) FindByTicketID(tx core.DB, ticketID string) (models.Flaw, error)

+ func (_m *IntegrationsFlawRepository) GetOrgFromFlawID(tx core.DB, flawID string) (models.Org, error)

+ func (_m *IntegrationsFlawRepository) Read(id string) (models.Flaw, error)

+ func (_m *IntegrationsFlawRepository) Save(db core.DB, flaw *models.Flaw) error

+ func (_m *IntegrationsFlawRepository) Transaction(fn func(core.DB) error) error

+ type IntegrationsFlawRepository_Expecter struct

+ func (_e *IntegrationsFlawRepository_Expecter) FindByTicketID(tx interface{}, ticketID interface{}) *IntegrationsFlawRepository_FindByTicketID_Call

+ func (_e *IntegrationsFlawRepository_Expecter) GetOrgFromFlawID(tx interface{}, flawID interface{}) *IntegrationsFlawRepository_GetOrgFromFlawID_Call

+ func (_e *IntegrationsFlawRepository_Expecter) Read(id interface{}) *IntegrationsFlawRepository_Read_Call

+ func (_e *IntegrationsFlawRepository_Expecter) Save(db interface{}, flaw interface{}) *IntegrationsFlawRepository_Save_Call

+ func (_e *IntegrationsFlawRepository_Expecter) Transaction(fn interface{}) *IntegrationsFlawRepository_Transaction_Call

+ type IntegrationsFlawRepository_FindByTicketID_Call struct

+ func (_c *IntegrationsFlawRepository_FindByTicketID_Call) Return(_a0 models.Flaw, _a1 error) *IntegrationsFlawRepository_FindByTicketID_Call

+ func (_c *IntegrationsFlawRepository_FindByTicketID_Call) Run(run func(tx core.DB, ticketID string)) *IntegrationsFlawRepository_FindByTicketID_Call

+ func (_c *IntegrationsFlawRepository_FindByTicketID_Call) RunAndReturn(run func(core.DB, string) (models.Flaw, error)) *IntegrationsFlawRepository_FindByTicketID_Call

+ type IntegrationsFlawRepository_GetOrgFromFlawID_Call struct

+ func (_c *IntegrationsFlawRepository_GetOrgFromFlawID_Call) Return(_a0 models.Org, _a1 error) *IntegrationsFlawRepository_GetOrgFromFlawID_Call

+ func (_c *IntegrationsFlawRepository_GetOrgFromFlawID_Call) Run(run func(tx core.DB, flawID string)) *IntegrationsFlawRepository_GetOrgFromFlawID_Call

+ func (_c *IntegrationsFlawRepository_GetOrgFromFlawID_Call) RunAndReturn(run func(core.DB, string) (models.Org, error)) *IntegrationsFlawRepository_GetOrgFromFlawID_Call

+ type IntegrationsFlawRepository_Read_Call struct

+ func (_c *IntegrationsFlawRepository_Read_Call) Return(_a0 models.Flaw, _a1 error) *IntegrationsFlawRepository_Read_Call

+ func (_c *IntegrationsFlawRepository_Read_Call) Run(run func(id string)) *IntegrationsFlawRepository_Read_Call

+ func (_c *IntegrationsFlawRepository_Read_Call) RunAndReturn(run func(string) (models.Flaw, error)) *IntegrationsFlawRepository_Read_Call

+ type IntegrationsFlawRepository_Save_Call struct

+ func (_c *IntegrationsFlawRepository_Save_Call) Return(_a0 error) *IntegrationsFlawRepository_Save_Call

+ func (_c *IntegrationsFlawRepository_Save_Call) Run(run func(db core.DB, flaw *models.Flaw)) *IntegrationsFlawRepository_Save_Call

+ func (_c *IntegrationsFlawRepository_Save_Call) RunAndReturn(run func(core.DB, *models.Flaw) error) *IntegrationsFlawRepository_Save_Call

+ type IntegrationsFlawRepository_Transaction_Call struct

+ func (_c *IntegrationsFlawRepository_Transaction_Call) Return(_a0 error) *IntegrationsFlawRepository_Transaction_Call

+ func (_c *IntegrationsFlawRepository_Transaction_Call) Run(run func(fn func(core.DB) error)) *IntegrationsFlawRepository_Transaction_Call

+ func (_c *IntegrationsFlawRepository_Transaction_Call) RunAndReturn(run func(func(core.DB) error) error) *IntegrationsFlawRepository_Transaction_Call

+ type IntegrationsFlawService struct

+ func NewIntegrationsFlawService(t interface{ ... }) *IntegrationsFlawService

+ func (_m *IntegrationsFlawService) ApplyAndSave(tx core.DB, flaw *models.Flaw, flawEvent *models.FlawEvent) error

+ func (_m *IntegrationsFlawService) EXPECT() *IntegrationsFlawService_Expecter

+ type IntegrationsFlawService_ApplyAndSave_Call struct

+ func (_c *IntegrationsFlawService_ApplyAndSave_Call) Return(_a0 error) *IntegrationsFlawService_ApplyAndSave_Call

+ func (_c *IntegrationsFlawService_ApplyAndSave_Call) Run(run func(tx core.DB, flaw *models.Flaw, flawEvent *models.FlawEvent)) *IntegrationsFlawService_ApplyAndSave_Call

+ func (_c *IntegrationsFlawService_ApplyAndSave_Call) RunAndReturn(run func(core.DB, *models.Flaw, *models.FlawEvent) error) *IntegrationsFlawService_ApplyAndSave_Call

+ type IntegrationsFlawService_Expecter struct

+ func (_e *IntegrationsFlawService_Expecter) ApplyAndSave(tx interface{}, flaw interface{}, flawEvent interface{}) *IntegrationsFlawService_ApplyAndSave_Call

+ type IntegrationsGithubClientFacade struct

+ func NewIntegrationsGithubClientFacade(t interface{ ... }) *IntegrationsGithubClientFacade

+ func (_m *IntegrationsGithubClientFacade) CreateIssue(ctx context.Context, owner string, repo string, issue *github.IssueRequest) (*github.Issue, *github.Response, error)

+ func (_m *IntegrationsGithubClientFacade) CreateIssueComment(ctx context.Context, owner string, repo string, number int, ...) (*github.IssueComment, *github.Response, error)

+ func (_m *IntegrationsGithubClientFacade) EXPECT() *IntegrationsGithubClientFacade_Expecter

+ func (_m *IntegrationsGithubClientFacade) EditIssue(ctx context.Context, owner string, repo string, number int, ...) (*github.Issue, *github.Response, error)

+ func (_m *IntegrationsGithubClientFacade) EditIssueLabel(ctx context.Context, owner string, repo string, name string, ...) (*github.Label, *github.Response, error)

+ type IntegrationsGithubClientFacade_CreateIssueComment_Call struct

+ func (_c *IntegrationsGithubClientFacade_CreateIssueComment_Call) Return(_a0 *github.IssueComment, _a1 *github.Response, _a2 error) *IntegrationsGithubClientFacade_CreateIssueComment_Call

+ func (_c *IntegrationsGithubClientFacade_CreateIssueComment_Call) Run(run func(ctx context.Context, owner string, repo string, number int, ...)) *IntegrationsGithubClientFacade_CreateIssueComment_Call

+ func (_c *IntegrationsGithubClientFacade_CreateIssueComment_Call) RunAndReturn(...) *IntegrationsGithubClientFacade_CreateIssueComment_Call

+ type IntegrationsGithubClientFacade_CreateIssue_Call struct

+ func (_c *IntegrationsGithubClientFacade_CreateIssue_Call) Return(_a0 *github.Issue, _a1 *github.Response, _a2 error) *IntegrationsGithubClientFacade_CreateIssue_Call

+ func (_c *IntegrationsGithubClientFacade_CreateIssue_Call) Run(...) *IntegrationsGithubClientFacade_CreateIssue_Call

+ func (_c *IntegrationsGithubClientFacade_CreateIssue_Call) RunAndReturn(...) *IntegrationsGithubClientFacade_CreateIssue_Call

+ type IntegrationsGithubClientFacade_EditIssueLabel_Call struct

+ func (_c *IntegrationsGithubClientFacade_EditIssueLabel_Call) Return(_a0 *github.Label, _a1 *github.Response, _a2 error) *IntegrationsGithubClientFacade_EditIssueLabel_Call

+ func (_c *IntegrationsGithubClientFacade_EditIssueLabel_Call) Run(run func(ctx context.Context, owner string, repo string, name string, ...)) *IntegrationsGithubClientFacade_EditIssueLabel_Call

+ func (_c *IntegrationsGithubClientFacade_EditIssueLabel_Call) RunAndReturn(...) *IntegrationsGithubClientFacade_EditIssueLabel_Call

+ type IntegrationsGithubClientFacade_EditIssue_Call struct

+ func (_c *IntegrationsGithubClientFacade_EditIssue_Call) Return(_a0 *github.Issue, _a1 *github.Response, _a2 error) *IntegrationsGithubClientFacade_EditIssue_Call

+ func (_c *IntegrationsGithubClientFacade_EditIssue_Call) Run(run func(ctx context.Context, owner string, repo string, number int, ...)) *IntegrationsGithubClientFacade_EditIssue_Call

+ func (_c *IntegrationsGithubClientFacade_EditIssue_Call) RunAndReturn(...) *IntegrationsGithubClientFacade_EditIssue_Call

+ type IntegrationsGithubClientFacade_Expecter struct

+ func (_e *IntegrationsGithubClientFacade_Expecter) CreateIssue(ctx interface{}, owner interface{}, repo interface{}, issue interface{}) *IntegrationsGithubClientFacade_CreateIssue_Call

+ func (_e *IntegrationsGithubClientFacade_Expecter) CreateIssueComment(ctx interface{}, owner interface{}, repo interface{}, number interface{}, ...) *IntegrationsGithubClientFacade_CreateIssueComment_Call

+ func (_e *IntegrationsGithubClientFacade_Expecter) EditIssue(ctx interface{}, owner interface{}, repo interface{}, number interface{}, ...) *IntegrationsGithubClientFacade_EditIssue_Call

+ func (_e *IntegrationsGithubClientFacade_Expecter) EditIssueLabel(ctx interface{}, owner interface{}, repo interface{}, name interface{}, ...) *IntegrationsGithubClientFacade_EditIssueLabel_Call

+ type IntegrationsGithubUserRepository struct

+ func NewIntegrationsGithubUserRepository(t interface{ ... }) *IntegrationsGithubUserRepository

+ func (_m *IntegrationsGithubUserRepository) EXPECT() *IntegrationsGithubUserRepository_Expecter

+ func (_m *IntegrationsGithubUserRepository) FindByOrgID(tx *gorm.DB, orgID uuid.UUID) ([]models.ExternalUser, error)

+ func (_m *IntegrationsGithubUserRepository) GetDB(tx *gorm.DB) *gorm.DB

+ func (_m *IntegrationsGithubUserRepository) Save(db *gorm.DB, user *models.ExternalUser) error

+ type IntegrationsGithubUserRepository_Expecter struct

+ func (_e *IntegrationsGithubUserRepository_Expecter) FindByOrgID(tx interface{}, orgID interface{}) *IntegrationsGithubUserRepository_FindByOrgID_Call

+ func (_e *IntegrationsGithubUserRepository_Expecter) GetDB(tx interface{}) *IntegrationsGithubUserRepository_GetDB_Call

+ func (_e *IntegrationsGithubUserRepository_Expecter) Save(db interface{}, user interface{}) *IntegrationsGithubUserRepository_Save_Call

+ type IntegrationsGithubUserRepository_FindByOrgID_Call struct

+ func (_c *IntegrationsGithubUserRepository_FindByOrgID_Call) Return(_a0 []models.ExternalUser, _a1 error) *IntegrationsGithubUserRepository_FindByOrgID_Call

+ func (_c *IntegrationsGithubUserRepository_FindByOrgID_Call) Run(run func(tx *gorm.DB, orgID uuid.UUID)) *IntegrationsGithubUserRepository_FindByOrgID_Call

+ func (_c *IntegrationsGithubUserRepository_FindByOrgID_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) ([]models.ExternalUser, error)) *IntegrationsGithubUserRepository_FindByOrgID_Call

+ type IntegrationsGithubUserRepository_GetDB_Call struct

+ func (_c *IntegrationsGithubUserRepository_GetDB_Call) Return(_a0 *gorm.DB) *IntegrationsGithubUserRepository_GetDB_Call

+ func (_c *IntegrationsGithubUserRepository_GetDB_Call) Run(run func(tx *gorm.DB)) *IntegrationsGithubUserRepository_GetDB_Call

+ func (_c *IntegrationsGithubUserRepository_GetDB_Call) RunAndReturn(run func(*gorm.DB) *gorm.DB) *IntegrationsGithubUserRepository_GetDB_Call

+ type IntegrationsGithubUserRepository_Save_Call struct

+ func (_c *IntegrationsGithubUserRepository_Save_Call) Return(_a0 error) *IntegrationsGithubUserRepository_Save_Call

+ func (_c *IntegrationsGithubUserRepository_Save_Call) Run(run func(db *gorm.DB, user *models.ExternalUser)) *IntegrationsGithubUserRepository_Save_Call

+ func (_c *IntegrationsGithubUserRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.ExternalUser) error) *IntegrationsGithubUserRepository_Save_Call

+ type IntegrationsGitlabClientFacade struct

+ func NewIntegrationsGitlabClientFacade(t interface{ ... }) *IntegrationsGitlabClientFacade

+ func (_m *IntegrationsGitlabClientFacade) AddProjectHook(ctx context.Context, projectId int, opt *gitlab.AddProjectHookOptions) (*gitlab.ProjectHook, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) CreateIssue(ctx context.Context, pid int, opt *gitlab.CreateIssueOptions) (*gitlab.Issue, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) CreateIssueComment(ctx context.Context, pid int, issue int, opt *gitlab.CreateIssueNoteOptions) (*gitlab.Note, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) CreateMergeRequest(ctx context.Context, project string, opt *gitlab.CreateMergeRequestOptions) (*gitlab.MergeRequest, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) CreateVariable(ctx context.Context, projectId int, opt *gitlab.CreateProjectVariableOptions) (*gitlab.ProjectVariable, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) DeleteProjectHook(ctx context.Context, projectId int, hookId int) (*gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) EXPECT() *IntegrationsGitlabClientFacade_Expecter

+ func (_m *IntegrationsGitlabClientFacade) EditIssue(ctx context.Context, pid int, issue int, opt *gitlab.UpdateIssueOptions) (*gitlab.Issue, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) EditIssueLabel(ctx context.Context, pid int, issue int, labels []*gitlab.CreateLabelOptions) (*gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) GetProject(ctx context.Context, projectId int) (*gitlab.Project, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) ListProjectHooks(ctx context.Context, projectId int, options *gitlab.ListProjectHooksOptions) ([]*gitlab.ProjectHook, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) ListVariables(ctx context.Context, projectId int, ...) ([]*gitlab.ProjectVariable, *gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) RemoveVariable(ctx context.Context, projectId int, key string) (*gitlab.Response, error)

+ func (_m *IntegrationsGitlabClientFacade) UpdateVariable(ctx context.Context, projectId int, key string, ...) (*gitlab.ProjectVariable, *gitlab.Response, error)

+ type IntegrationsGitlabClientFacade_AddProjectHook_Call struct

+ func (_c *IntegrationsGitlabClientFacade_AddProjectHook_Call) Return(_a0 *gitlab.ProjectHook, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_AddProjectHook_Call

+ func (_c *IntegrationsGitlabClientFacade_AddProjectHook_Call) Run(...) *IntegrationsGitlabClientFacade_AddProjectHook_Call

+ func (_c *IntegrationsGitlabClientFacade_AddProjectHook_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_AddProjectHook_Call

+ type IntegrationsGitlabClientFacade_CreateIssueComment_Call struct

+ func (_c *IntegrationsGitlabClientFacade_CreateIssueComment_Call) Return(_a0 *gitlab.Note, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_CreateIssueComment_Call

+ func (_c *IntegrationsGitlabClientFacade_CreateIssueComment_Call) Run(...) *IntegrationsGitlabClientFacade_CreateIssueComment_Call

+ func (_c *IntegrationsGitlabClientFacade_CreateIssueComment_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_CreateIssueComment_Call

+ type IntegrationsGitlabClientFacade_CreateIssue_Call struct

+ func (_c *IntegrationsGitlabClientFacade_CreateIssue_Call) Return(_a0 *gitlab.Issue, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_CreateIssue_Call

+ func (_c *IntegrationsGitlabClientFacade_CreateIssue_Call) Run(run func(ctx context.Context, pid int, opt *gitlab.CreateIssueOptions)) *IntegrationsGitlabClientFacade_CreateIssue_Call

+ func (_c *IntegrationsGitlabClientFacade_CreateIssue_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_CreateIssue_Call

+ type IntegrationsGitlabClientFacade_CreateMergeRequest_Call struct

+ func (_c *IntegrationsGitlabClientFacade_CreateMergeRequest_Call) Return(_a0 *gitlab.MergeRequest, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_CreateMergeRequest_Call

+ func (_c *IntegrationsGitlabClientFacade_CreateMergeRequest_Call) Run(...) *IntegrationsGitlabClientFacade_CreateMergeRequest_Call

+ func (_c *IntegrationsGitlabClientFacade_CreateMergeRequest_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_CreateMergeRequest_Call

+ type IntegrationsGitlabClientFacade_CreateVariable_Call struct

+ func (_c *IntegrationsGitlabClientFacade_CreateVariable_Call) Return(_a0 *gitlab.ProjectVariable, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_CreateVariable_Call

+ func (_c *IntegrationsGitlabClientFacade_CreateVariable_Call) Run(...) *IntegrationsGitlabClientFacade_CreateVariable_Call

+ func (_c *IntegrationsGitlabClientFacade_CreateVariable_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_CreateVariable_Call

+ type IntegrationsGitlabClientFacade_DeleteProjectHook_Call struct

+ func (_c *IntegrationsGitlabClientFacade_DeleteProjectHook_Call) Return(_a0 *gitlab.Response, _a1 error) *IntegrationsGitlabClientFacade_DeleteProjectHook_Call

+ func (_c *IntegrationsGitlabClientFacade_DeleteProjectHook_Call) Run(run func(ctx context.Context, projectId int, hookId int)) *IntegrationsGitlabClientFacade_DeleteProjectHook_Call

+ func (_c *IntegrationsGitlabClientFacade_DeleteProjectHook_Call) RunAndReturn(run func(context.Context, int, int) (*gitlab.Response, error)) *IntegrationsGitlabClientFacade_DeleteProjectHook_Call

+ type IntegrationsGitlabClientFacade_EditIssueLabel_Call struct

+ func (_c *IntegrationsGitlabClientFacade_EditIssueLabel_Call) Return(_a0 *gitlab.Response, _a1 error) *IntegrationsGitlabClientFacade_EditIssueLabel_Call

+ func (_c *IntegrationsGitlabClientFacade_EditIssueLabel_Call) Run(...) *IntegrationsGitlabClientFacade_EditIssueLabel_Call

+ func (_c *IntegrationsGitlabClientFacade_EditIssueLabel_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_EditIssueLabel_Call

+ type IntegrationsGitlabClientFacade_EditIssue_Call struct

+ func (_c *IntegrationsGitlabClientFacade_EditIssue_Call) Return(_a0 *gitlab.Issue, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_EditIssue_Call

+ func (_c *IntegrationsGitlabClientFacade_EditIssue_Call) Run(...) *IntegrationsGitlabClientFacade_EditIssue_Call

+ func (_c *IntegrationsGitlabClientFacade_EditIssue_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_EditIssue_Call

+ type IntegrationsGitlabClientFacade_Expecter struct

+ func (_e *IntegrationsGitlabClientFacade_Expecter) AddProjectHook(ctx interface{}, projectId interface{}, opt interface{}) *IntegrationsGitlabClientFacade_AddProjectHook_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) CreateIssue(ctx interface{}, pid interface{}, opt interface{}) *IntegrationsGitlabClientFacade_CreateIssue_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) CreateIssueComment(ctx interface{}, pid interface{}, issue interface{}, opt interface{}) *IntegrationsGitlabClientFacade_CreateIssueComment_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) CreateMergeRequest(ctx interface{}, project interface{}, opt interface{}) *IntegrationsGitlabClientFacade_CreateMergeRequest_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) CreateVariable(ctx interface{}, projectId interface{}, opt interface{}) *IntegrationsGitlabClientFacade_CreateVariable_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) DeleteProjectHook(ctx interface{}, projectId interface{}, hookId interface{}) *IntegrationsGitlabClientFacade_DeleteProjectHook_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) EditIssue(ctx interface{}, pid interface{}, issue interface{}, opt interface{}) *IntegrationsGitlabClientFacade_EditIssue_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) EditIssueLabel(ctx interface{}, pid interface{}, issue interface{}, labels interface{}) *IntegrationsGitlabClientFacade_EditIssueLabel_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) GetProject(ctx interface{}, projectId interface{}) *IntegrationsGitlabClientFacade_GetProject_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) ListProjectHooks(ctx interface{}, projectId interface{}, options interface{}) *IntegrationsGitlabClientFacade_ListProjectHooks_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) ListVariables(ctx interface{}, projectId interface{}, options interface{}) *IntegrationsGitlabClientFacade_ListVariables_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) RemoveVariable(ctx interface{}, projectId interface{}, key interface{}) *IntegrationsGitlabClientFacade_RemoveVariable_Call

+ func (_e *IntegrationsGitlabClientFacade_Expecter) UpdateVariable(ctx interface{}, projectId interface{}, key interface{}, opt interface{}) *IntegrationsGitlabClientFacade_UpdateVariable_Call

+ type IntegrationsGitlabClientFacade_GetProject_Call struct

+ func (_c *IntegrationsGitlabClientFacade_GetProject_Call) Return(_a0 *gitlab.Project, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_GetProject_Call

+ func (_c *IntegrationsGitlabClientFacade_GetProject_Call) Run(run func(ctx context.Context, projectId int)) *IntegrationsGitlabClientFacade_GetProject_Call

+ func (_c *IntegrationsGitlabClientFacade_GetProject_Call) RunAndReturn(run func(context.Context, int) (*gitlab.Project, *gitlab.Response, error)) *IntegrationsGitlabClientFacade_GetProject_Call

+ type IntegrationsGitlabClientFacade_ListProjectHooks_Call struct

+ func (_c *IntegrationsGitlabClientFacade_ListProjectHooks_Call) Return(_a0 []*gitlab.ProjectHook, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_ListProjectHooks_Call

+ func (_c *IntegrationsGitlabClientFacade_ListProjectHooks_Call) Run(...) *IntegrationsGitlabClientFacade_ListProjectHooks_Call

+ func (_c *IntegrationsGitlabClientFacade_ListProjectHooks_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_ListProjectHooks_Call

+ type IntegrationsGitlabClientFacade_ListVariables_Call struct

+ func (_c *IntegrationsGitlabClientFacade_ListVariables_Call) Return(_a0 []*gitlab.ProjectVariable, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_ListVariables_Call

+ func (_c *IntegrationsGitlabClientFacade_ListVariables_Call) Run(run func(ctx context.Context, projectId int, ...)) *IntegrationsGitlabClientFacade_ListVariables_Call

+ func (_c *IntegrationsGitlabClientFacade_ListVariables_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_ListVariables_Call

+ type IntegrationsGitlabClientFacade_RemoveVariable_Call struct

+ func (_c *IntegrationsGitlabClientFacade_RemoveVariable_Call) Return(_a0 *gitlab.Response, _a1 error) *IntegrationsGitlabClientFacade_RemoveVariable_Call

+ func (_c *IntegrationsGitlabClientFacade_RemoveVariable_Call) Run(run func(ctx context.Context, projectId int, key string)) *IntegrationsGitlabClientFacade_RemoveVariable_Call

+ func (_c *IntegrationsGitlabClientFacade_RemoveVariable_Call) RunAndReturn(run func(context.Context, int, string) (*gitlab.Response, error)) *IntegrationsGitlabClientFacade_RemoveVariable_Call

+ type IntegrationsGitlabClientFacade_UpdateVariable_Call struct

+ func (_c *IntegrationsGitlabClientFacade_UpdateVariable_Call) Return(_a0 *gitlab.ProjectVariable, _a1 *gitlab.Response, _a2 error) *IntegrationsGitlabClientFacade_UpdateVariable_Call

+ func (_c *IntegrationsGitlabClientFacade_UpdateVariable_Call) Run(run func(ctx context.Context, projectId int, key string, ...)) *IntegrationsGitlabClientFacade_UpdateVariable_Call

+ func (_c *IntegrationsGitlabClientFacade_UpdateVariable_Call) RunAndReturn(...) *IntegrationsGitlabClientFacade_UpdateVariable_Call

+ type IntegrationsGitlabIntegrationRepository struct

+ func NewIntegrationsGitlabIntegrationRepository(t interface{ ... }) *IntegrationsGitlabIntegrationRepository

+ func (_m *IntegrationsGitlabIntegrationRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_m *IntegrationsGitlabIntegrationRepository) EXPECT() *IntegrationsGitlabIntegrationRepository_Expecter

+ func (_m *IntegrationsGitlabIntegrationRepository) FindByOrganizationId(orgID uuid.UUID) ([]models.GitLabIntegration, error)

+ func (_m *IntegrationsGitlabIntegrationRepository) Read(id uuid.UUID) (models.GitLabIntegration, error)

+ func (_m *IntegrationsGitlabIntegrationRepository) Save(tx core.DB, model *models.GitLabIntegration) error

+ type IntegrationsGitlabIntegrationRepository_Delete_Call struct

+ func (_c *IntegrationsGitlabIntegrationRepository_Delete_Call) Return(_a0 error) *IntegrationsGitlabIntegrationRepository_Delete_Call

+ func (_c *IntegrationsGitlabIntegrationRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *IntegrationsGitlabIntegrationRepository_Delete_Call

+ func (_c *IntegrationsGitlabIntegrationRepository_Delete_Call) RunAndReturn(run func(core.DB, uuid.UUID) error) *IntegrationsGitlabIntegrationRepository_Delete_Call

+ type IntegrationsGitlabIntegrationRepository_Expecter struct

+ func (_e *IntegrationsGitlabIntegrationRepository_Expecter) Delete(tx interface{}, id interface{}) *IntegrationsGitlabIntegrationRepository_Delete_Call

+ func (_e *IntegrationsGitlabIntegrationRepository_Expecter) FindByOrganizationId(orgID interface{}) *IntegrationsGitlabIntegrationRepository_FindByOrganizationId_Call

+ func (_e *IntegrationsGitlabIntegrationRepository_Expecter) Read(id interface{}) *IntegrationsGitlabIntegrationRepository_Read_Call

+ func (_e *IntegrationsGitlabIntegrationRepository_Expecter) Save(tx interface{}, model interface{}) *IntegrationsGitlabIntegrationRepository_Save_Call

+ type IntegrationsGitlabIntegrationRepository_FindByOrganizationId_Call struct

+ func (_c *IntegrationsGitlabIntegrationRepository_FindByOrganizationId_Call) Return(_a0 []models.GitLabIntegration, _a1 error) *IntegrationsGitlabIntegrationRepository_FindByOrganizationId_Call

+ func (_c *IntegrationsGitlabIntegrationRepository_FindByOrganizationId_Call) Run(run func(orgID uuid.UUID)) *IntegrationsGitlabIntegrationRepository_FindByOrganizationId_Call

+ func (_c *IntegrationsGitlabIntegrationRepository_FindByOrganizationId_Call) RunAndReturn(run func(uuid.UUID) ([]models.GitLabIntegration, error)) *IntegrationsGitlabIntegrationRepository_FindByOrganizationId_Call

+ type IntegrationsGitlabIntegrationRepository_Read_Call struct

+ func (_c *IntegrationsGitlabIntegrationRepository_Read_Call) Return(_a0 models.GitLabIntegration, _a1 error) *IntegrationsGitlabIntegrationRepository_Read_Call

+ func (_c *IntegrationsGitlabIntegrationRepository_Read_Call) Run(run func(id uuid.UUID)) *IntegrationsGitlabIntegrationRepository_Read_Call

+ func (_c *IntegrationsGitlabIntegrationRepository_Read_Call) RunAndReturn(run func(uuid.UUID) (models.GitLabIntegration, error)) *IntegrationsGitlabIntegrationRepository_Read_Call

+ type IntegrationsGitlabIntegrationRepository_Save_Call struct

+ func (_c *IntegrationsGitlabIntegrationRepository_Save_Call) Return(_a0 error) *IntegrationsGitlabIntegrationRepository_Save_Call

+ func (_c *IntegrationsGitlabIntegrationRepository_Save_Call) Run(run func(tx core.DB, model *models.GitLabIntegration)) *IntegrationsGitlabIntegrationRepository_Save_Call

+ func (_c *IntegrationsGitlabIntegrationRepository_Save_Call) RunAndReturn(run func(core.DB, *models.GitLabIntegration) error) *IntegrationsGitlabIntegrationRepository_Save_Call

+ type IntotoAccessControl struct

+ func NewIntotoAccessControl(t interface{ ... }) *IntotoAccessControl

+ func (_m *IntotoAccessControl) EXPECT() *IntotoAccessControl_Expecter

+ func (_m *IntotoAccessControl) GetAllMembersOfProject(organizationID string, projectID string) ([]string, error)

+ type IntotoAccessControl_Expecter struct

+ func (_e *IntotoAccessControl_Expecter) GetAllMembersOfProject(organizationID interface{}, projectID interface{}) *IntotoAccessControl_GetAllMembersOfProject_Call

+ type IntotoAccessControl_GetAllMembersOfProject_Call struct

+ func (_c *IntotoAccessControl_GetAllMembersOfProject_Call) Return(_a0 []string, _a1 error) *IntotoAccessControl_GetAllMembersOfProject_Call

+ func (_c *IntotoAccessControl_GetAllMembersOfProject_Call) Run(run func(organizationID string, projectID string)) *IntotoAccessControl_GetAllMembersOfProject_Call

+ func (_c *IntotoAccessControl_GetAllMembersOfProject_Call) RunAndReturn(run func(string, string) ([]string, error)) *IntotoAccessControl_GetAllMembersOfProject_Call

+ type IntotoInTotoLinkRepository struct

+ func NewIntotoInTotoLinkRepository(t interface{ ... }) *IntotoInTotoLinkRepository

+ func (_m *IntotoInTotoLinkRepository) EXPECT() *IntotoInTotoLinkRepository_Expecter

+ func (_m *IntotoInTotoLinkRepository) FindBySupplyChainID(supplyChainID string) ([]models.InTotoLink, error)

+ type IntotoInTotoLinkRepository_Expecter struct

+ func (_e *IntotoInTotoLinkRepository_Expecter) FindBySupplyChainID(supplyChainID interface{}) *IntotoInTotoLinkRepository_FindBySupplyChainID_Call

+ type IntotoInTotoLinkRepository_FindBySupplyChainID_Call struct

+ func (_c *IntotoInTotoLinkRepository_FindBySupplyChainID_Call) Return(_a0 []models.InTotoLink, _a1 error) *IntotoInTotoLinkRepository_FindBySupplyChainID_Call

+ func (_c *IntotoInTotoLinkRepository_FindBySupplyChainID_Call) Run(run func(supplyChainID string)) *IntotoInTotoLinkRepository_FindBySupplyChainID_Call

+ func (_c *IntotoInTotoLinkRepository_FindBySupplyChainID_Call) RunAndReturn(run func(string) ([]models.InTotoLink, error)) *IntotoInTotoLinkRepository_FindBySupplyChainID_Call

+ type IntotoInTotoVerifierService struct

+ func NewIntotoInTotoVerifierService(t interface{ ... }) *IntotoInTotoVerifierService

+ func (_m *IntotoInTotoVerifierService) EXPECT() *IntotoInTotoVerifierService_Expecter

+ func (_m *IntotoInTotoVerifierService) VerifyWithImageName(imageName string, digest string) error

+ func (_m *IntotoInTotoVerifierService) VerifyWithSupplyChainID(supplyChainID string) error

+ type IntotoInTotoVerifierService_Expecter struct

+ func (_e *IntotoInTotoVerifierService_Expecter) VerifyWithImageName(imageName interface{}, digest interface{}) *IntotoInTotoVerifierService_VerifyWithImageName_Call

+ func (_e *IntotoInTotoVerifierService_Expecter) VerifyWithSupplyChainID(supplyChainID interface{}) *IntotoInTotoVerifierService_VerifyWithSupplyChainID_Call

+ type IntotoInTotoVerifierService_VerifyWithImageName_Call struct

+ func (_c *IntotoInTotoVerifierService_VerifyWithImageName_Call) Return(_a0 error) *IntotoInTotoVerifierService_VerifyWithImageName_Call

+ func (_c *IntotoInTotoVerifierService_VerifyWithImageName_Call) Run(run func(imageName string, digest string)) *IntotoInTotoVerifierService_VerifyWithImageName_Call

+ func (_c *IntotoInTotoVerifierService_VerifyWithImageName_Call) RunAndReturn(run func(string, string) error) *IntotoInTotoVerifierService_VerifyWithImageName_Call

+ type IntotoInTotoVerifierService_VerifyWithSupplyChainID_Call struct

+ func (_c *IntotoInTotoVerifierService_VerifyWithSupplyChainID_Call) Return(_a0 error) *IntotoInTotoVerifierService_VerifyWithSupplyChainID_Call

+ func (_c *IntotoInTotoVerifierService_VerifyWithSupplyChainID_Call) Run(run func(supplyChainID string)) *IntotoInTotoVerifierService_VerifyWithSupplyChainID_Call

+ func (_c *IntotoInTotoVerifierService_VerifyWithSupplyChainID_Call) RunAndReturn(run func(string) error) *IntotoInTotoVerifierService_VerifyWithSupplyChainID_Call

+ type IntotoPatRepository struct

+ func NewIntotoPatRepository(t interface{ ... }) *IntotoPatRepository

+ func (_m *IntotoPatRepository) EXPECT() *IntotoPatRepository_Expecter

+ func (_m *IntotoPatRepository) FindByUserIDs(userID []uuid.UUID) ([]models.PAT, error)

+ func (_m *IntotoPatRepository) GetByFingerprint(fingerprint string) (models.PAT, error)

+ type IntotoPatRepository_Expecter struct

+ func (_e *IntotoPatRepository_Expecter) FindByUserIDs(userID interface{}) *IntotoPatRepository_FindByUserIDs_Call

+ func (_e *IntotoPatRepository_Expecter) GetByFingerprint(fingerprint interface{}) *IntotoPatRepository_GetByFingerprint_Call

+ type IntotoPatRepository_FindByUserIDs_Call struct

+ func (_c *IntotoPatRepository_FindByUserIDs_Call) Return(_a0 []models.PAT, _a1 error) *IntotoPatRepository_FindByUserIDs_Call

+ func (_c *IntotoPatRepository_FindByUserIDs_Call) Run(run func(userID []uuid.UUID)) *IntotoPatRepository_FindByUserIDs_Call

+ func (_c *IntotoPatRepository_FindByUserIDs_Call) RunAndReturn(run func([]uuid.UUID) ([]models.PAT, error)) *IntotoPatRepository_FindByUserIDs_Call

+ type IntotoPatRepository_GetByFingerprint_Call struct

+ func (_c *IntotoPatRepository_GetByFingerprint_Call) Return(_a0 models.PAT, _a1 error) *IntotoPatRepository_GetByFingerprint_Call

+ func (_c *IntotoPatRepository_GetByFingerprint_Call) Run(run func(fingerprint string)) *IntotoPatRepository_GetByFingerprint_Call

+ func (_c *IntotoPatRepository_GetByFingerprint_Call) RunAndReturn(run func(string) (models.PAT, error)) *IntotoPatRepository_GetByFingerprint_Call

+ type IntotoProjectRepository struct

+ func NewIntotoProjectRepository(t interface{ ... }) *IntotoProjectRepository

+ func (_m *IntotoProjectRepository) EXPECT() *IntotoProjectRepository_Expecter

+ func (_m *IntotoProjectRepository) GetProjectByAssetID(assetID uuid.UUID) (models.Project, error)

+ type IntotoProjectRepository_Expecter struct

+ func (_e *IntotoProjectRepository_Expecter) GetProjectByAssetID(assetID interface{}) *IntotoProjectRepository_GetProjectByAssetID_Call

+ type IntotoProjectRepository_GetProjectByAssetID_Call struct

+ func (_c *IntotoProjectRepository_GetProjectByAssetID_Call) Return(_a0 models.Project, _a1 error) *IntotoProjectRepository_GetProjectByAssetID_Call

+ func (_c *IntotoProjectRepository_GetProjectByAssetID_Call) Run(run func(assetID uuid.UUID)) *IntotoProjectRepository_GetProjectByAssetID_Call

+ func (_c *IntotoProjectRepository_GetProjectByAssetID_Call) RunAndReturn(run func(uuid.UUID) (models.Project, error)) *IntotoProjectRepository_GetProjectByAssetID_Call

+ type IntotoRepository struct

+ func NewIntotoRepository(t interface{ ... }) *IntotoRepository

+ func (_m *IntotoRepository) Begin() core.DB

+ func (_m *IntotoRepository) Create(tx core.DB, t *models.InTotoLink) error

+ func (_m *IntotoRepository) CreateBatch(tx core.DB, ts []models.InTotoLink) error

+ func (_m *IntotoRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_m *IntotoRepository) EXPECT() *IntotoRepository_Expecter

+ func (_m *IntotoRepository) FindByAssetAndSupplyChainId(assetID uuid.UUID, supplyChainId string) ([]models.InTotoLink, error)

+ func (_m *IntotoRepository) GetDB(tx core.DB) core.DB

+ func (_m *IntotoRepository) List(ids []uuid.UUID) ([]models.InTotoLink, error)

+ func (_m *IntotoRepository) Read(id uuid.UUID) (models.InTotoLink, error)

+ func (_m *IntotoRepository) Save(tx core.DB, model *models.InTotoLink) error

+ func (_m *IntotoRepository) SaveBatch(tx core.DB, ts []models.InTotoLink) error

+ func (_m *IntotoRepository) Transaction(_a0 func(core.DB) error) error

+ type IntotoRepository_Begin_Call struct

+ func (_c *IntotoRepository_Begin_Call) Return(_a0 core.DB) *IntotoRepository_Begin_Call

+ func (_c *IntotoRepository_Begin_Call) Run(run func()) *IntotoRepository_Begin_Call

+ func (_c *IntotoRepository_Begin_Call) RunAndReturn(run func() core.DB) *IntotoRepository_Begin_Call

+ type IntotoRepository_CreateBatch_Call struct

+ func (_c *IntotoRepository_CreateBatch_Call) Return(_a0 error) *IntotoRepository_CreateBatch_Call

+ func (_c *IntotoRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.InTotoLink)) *IntotoRepository_CreateBatch_Call

+ func (_c *IntotoRepository_CreateBatch_Call) RunAndReturn(run func(core.DB, []models.InTotoLink) error) *IntotoRepository_CreateBatch_Call

+ type IntotoRepository_Create_Call struct

+ func (_c *IntotoRepository_Create_Call) Return(_a0 error) *IntotoRepository_Create_Call

+ func (_c *IntotoRepository_Create_Call) Run(run func(tx core.DB, t *models.InTotoLink)) *IntotoRepository_Create_Call

+ func (_c *IntotoRepository_Create_Call) RunAndReturn(run func(core.DB, *models.InTotoLink) error) *IntotoRepository_Create_Call

+ type IntotoRepository_Delete_Call struct

+ func (_c *IntotoRepository_Delete_Call) Return(_a0 error) *IntotoRepository_Delete_Call

+ func (_c *IntotoRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *IntotoRepository_Delete_Call

+ func (_c *IntotoRepository_Delete_Call) RunAndReturn(run func(core.DB, uuid.UUID) error) *IntotoRepository_Delete_Call

+ type IntotoRepository_Expecter struct

+ func (_e *IntotoRepository_Expecter) Begin() *IntotoRepository_Begin_Call

+ func (_e *IntotoRepository_Expecter) Create(tx interface{}, t interface{}) *IntotoRepository_Create_Call

+ func (_e *IntotoRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *IntotoRepository_CreateBatch_Call

+ func (_e *IntotoRepository_Expecter) Delete(tx interface{}, id interface{}) *IntotoRepository_Delete_Call

+ func (_e *IntotoRepository_Expecter) FindByAssetAndSupplyChainId(assetID interface{}, supplyChainId interface{}) *IntotoRepository_FindByAssetAndSupplyChainId_Call

+ func (_e *IntotoRepository_Expecter) GetDB(tx interface{}) *IntotoRepository_GetDB_Call

+ func (_e *IntotoRepository_Expecter) List(ids interface{}) *IntotoRepository_List_Call

+ func (_e *IntotoRepository_Expecter) Read(id interface{}) *IntotoRepository_Read_Call

+ func (_e *IntotoRepository_Expecter) Save(tx interface{}, model interface{}) *IntotoRepository_Save_Call

+ func (_e *IntotoRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *IntotoRepository_SaveBatch_Call

+ func (_e *IntotoRepository_Expecter) Transaction(_a0 interface{}) *IntotoRepository_Transaction_Call

+ type IntotoRepository_FindByAssetAndSupplyChainId_Call struct

+ func (_c *IntotoRepository_FindByAssetAndSupplyChainId_Call) Return(_a0 []models.InTotoLink, _a1 error) *IntotoRepository_FindByAssetAndSupplyChainId_Call

+ func (_c *IntotoRepository_FindByAssetAndSupplyChainId_Call) Run(run func(assetID uuid.UUID, supplyChainId string)) *IntotoRepository_FindByAssetAndSupplyChainId_Call

+ func (_c *IntotoRepository_FindByAssetAndSupplyChainId_Call) RunAndReturn(run func(uuid.UUID, string) ([]models.InTotoLink, error)) *IntotoRepository_FindByAssetAndSupplyChainId_Call

+ type IntotoRepository_GetDB_Call struct

+ func (_c *IntotoRepository_GetDB_Call) Return(_a0 core.DB) *IntotoRepository_GetDB_Call

+ func (_c *IntotoRepository_GetDB_Call) Run(run func(tx core.DB)) *IntotoRepository_GetDB_Call

+ func (_c *IntotoRepository_GetDB_Call) RunAndReturn(run func(core.DB) core.DB) *IntotoRepository_GetDB_Call

+ type IntotoRepository_List_Call struct

+ func (_c *IntotoRepository_List_Call) Return(_a0 []models.InTotoLink, _a1 error) *IntotoRepository_List_Call

+ func (_c *IntotoRepository_List_Call) Run(run func(ids []uuid.UUID)) *IntotoRepository_List_Call

+ func (_c *IntotoRepository_List_Call) RunAndReturn(run func([]uuid.UUID) ([]models.InTotoLink, error)) *IntotoRepository_List_Call

+ type IntotoRepository_Read_Call struct

+ func (_c *IntotoRepository_Read_Call) Return(_a0 models.InTotoLink, _a1 error) *IntotoRepository_Read_Call

+ func (_c *IntotoRepository_Read_Call) Run(run func(id uuid.UUID)) *IntotoRepository_Read_Call

+ func (_c *IntotoRepository_Read_Call) RunAndReturn(run func(uuid.UUID) (models.InTotoLink, error)) *IntotoRepository_Read_Call

+ type IntotoRepository_SaveBatch_Call struct

+ func (_c *IntotoRepository_SaveBatch_Call) Return(_a0 error) *IntotoRepository_SaveBatch_Call

+ func (_c *IntotoRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.InTotoLink)) *IntotoRepository_SaveBatch_Call

+ func (_c *IntotoRepository_SaveBatch_Call) RunAndReturn(run func(core.DB, []models.InTotoLink) error) *IntotoRepository_SaveBatch_Call

+ type IntotoRepository_Save_Call struct

+ func (_c *IntotoRepository_Save_Call) Return(_a0 error) *IntotoRepository_Save_Call

+ func (_c *IntotoRepository_Save_Call) Run(run func(tx core.DB, model *models.InTotoLink)) *IntotoRepository_Save_Call

+ func (_c *IntotoRepository_Save_Call) RunAndReturn(run func(core.DB, *models.InTotoLink) error) *IntotoRepository_Save_Call

+ type IntotoRepository_Transaction_Call struct

+ func (_c *IntotoRepository_Transaction_Call) Return(_a0 error) *IntotoRepository_Transaction_Call

+ func (_c *IntotoRepository_Transaction_Call) Run(run func(_a0 func(core.DB) error)) *IntotoRepository_Transaction_Call

+ func (_c *IntotoRepository_Transaction_Call) RunAndReturn(run func(func(core.DB) error) error) *IntotoRepository_Transaction_Call

+ type IntotoSupplyChainRepository struct

+ func NewIntotoSupplyChainRepository(t interface{ ... }) *IntotoSupplyChainRepository

+ func (_m *IntotoSupplyChainRepository) EXPECT() *IntotoSupplyChainRepository_Expecter

+ func (_m *IntotoSupplyChainRepository) Save(tx core.DB, model *models.SupplyChain) error

+ type IntotoSupplyChainRepositoryS struct

+ func NewIntotoSupplyChainRepositoryS(t interface{ ... }) *IntotoSupplyChainRepositoryS

+ func (_m *IntotoSupplyChainRepositoryS) EXPECT() *IntotoSupplyChainRepositoryS_Expecter

+ func (_m *IntotoSupplyChainRepositoryS) FindBySupplyChainID(supplyChainID string) ([]models.SupplyChain, error)

+ type IntotoSupplyChainRepositoryS_Expecter struct

+ func (_e *IntotoSupplyChainRepositoryS_Expecter) FindBySupplyChainID(supplyChainID interface{}) *IntotoSupplyChainRepositoryS_FindBySupplyChainID_Call

+ type IntotoSupplyChainRepositoryS_FindBySupplyChainID_Call struct

+ func (_c *IntotoSupplyChainRepositoryS_FindBySupplyChainID_Call) Return(_a0 []models.SupplyChain, _a1 error) *IntotoSupplyChainRepositoryS_FindBySupplyChainID_Call

+ func (_c *IntotoSupplyChainRepositoryS_FindBySupplyChainID_Call) Run(run func(supplyChainID string)) *IntotoSupplyChainRepositoryS_FindBySupplyChainID_Call

+ func (_c *IntotoSupplyChainRepositoryS_FindBySupplyChainID_Call) RunAndReturn(run func(string) ([]models.SupplyChain, error)) *IntotoSupplyChainRepositoryS_FindBySupplyChainID_Call

+ type IntotoSupplyChainRepository_Expecter struct

+ func (_e *IntotoSupplyChainRepository_Expecter) Save(tx interface{}, model interface{}) *IntotoSupplyChainRepository_Save_Call

+ type IntotoSupplyChainRepository_Save_Call struct

+ func (_c *IntotoSupplyChainRepository_Save_Call) Return(_a0 error) *IntotoSupplyChainRepository_Save_Call

+ func (_c *IntotoSupplyChainRepository_Save_Call) Run(run func(tx core.DB, model *models.SupplyChain)) *IntotoSupplyChainRepository_Save_Call

+ func (_c *IntotoSupplyChainRepository_Save_Call) RunAndReturn(run func(core.DB, *models.SupplyChain) error) *IntotoSupplyChainRepository_Save_Call

+ type OrgInvitationRepository struct

+ func NewOrgInvitationRepository(t interface{ ... }) *OrgInvitationRepository

+ func (_m *OrgInvitationRepository) Delete(tx core.DB, id uuid.UUID) error

+ func (_m *OrgInvitationRepository) EXPECT() *OrgInvitationRepository_Expecter

+ func (_m *OrgInvitationRepository) FindByCode(code string) (models.Invitation, error)

+ func (_m *OrgInvitationRepository) Save(tx core.DB, invitation *models.Invitation) error

+ type OrgInvitationRepository_Delete_Call struct

+ func (_c *OrgInvitationRepository_Delete_Call) Return(_a0 error) *OrgInvitationRepository_Delete_Call

+ func (_c *OrgInvitationRepository_Delete_Call) Run(run func(tx core.DB, id uuid.UUID)) *OrgInvitationRepository_Delete_Call

+ func (_c *OrgInvitationRepository_Delete_Call) RunAndReturn(run func(core.DB, uuid.UUID) error) *OrgInvitationRepository_Delete_Call

+ type OrgInvitationRepository_Expecter struct

+ func (_e *OrgInvitationRepository_Expecter) Delete(tx interface{}, id interface{}) *OrgInvitationRepository_Delete_Call

+ func (_e *OrgInvitationRepository_Expecter) FindByCode(code interface{}) *OrgInvitationRepository_FindByCode_Call

+ func (_e *OrgInvitationRepository_Expecter) Save(tx interface{}, invitation interface{}) *OrgInvitationRepository_Save_Call

+ type OrgInvitationRepository_FindByCode_Call struct

+ func (_c *OrgInvitationRepository_FindByCode_Call) Return(_a0 models.Invitation, _a1 error) *OrgInvitationRepository_FindByCode_Call

+ func (_c *OrgInvitationRepository_FindByCode_Call) Run(run func(code string)) *OrgInvitationRepository_FindByCode_Call

+ func (_c *OrgInvitationRepository_FindByCode_Call) RunAndReturn(run func(string) (models.Invitation, error)) *OrgInvitationRepository_FindByCode_Call

+ type OrgInvitationRepository_Save_Call struct

+ func (_c *OrgInvitationRepository_Save_Call) Return(_a0 error) *OrgInvitationRepository_Save_Call

+ func (_c *OrgInvitationRepository_Save_Call) Run(run func(tx core.DB, invitation *models.Invitation)) *OrgInvitationRepository_Save_Call

+ func (_c *OrgInvitationRepository_Save_Call) RunAndReturn(run func(core.DB, *models.Invitation) error) *OrgInvitationRepository_Save_Call

+ type OrgProjectService struct

+ func NewOrgProjectService(t interface{ ... }) *OrgProjectService

+ func (_m *OrgProjectService) EXPECT() *OrgProjectService_Expecter

+ func (_m *OrgProjectService) ListAllowedProjects(c core.Context) ([]models.Project, error)

+ type OrgProjectService_Expecter struct

+ func (_e *OrgProjectService_Expecter) ListAllowedProjects(c interface{}) *OrgProjectService_ListAllowedProjects_Call

+ type OrgProjectService_ListAllowedProjects_Call struct

+ func (_c *OrgProjectService_ListAllowedProjects_Call) Return(_a0 []models.Project, _a1 error) *OrgProjectService_ListAllowedProjects_Call

+ func (_c *OrgProjectService_ListAllowedProjects_Call) Run(run func(c core.Context)) *OrgProjectService_ListAllowedProjects_Call

+ func (_c *OrgProjectService_ListAllowedProjects_Call) RunAndReturn(run func(core.Context) ([]models.Project, error)) *OrgProjectService_ListAllowedProjects_Call

type OrgRepository

+ func (_m *OrgRepository) ContentTree(orgID uuid.UUID, projects []string) []obj.ContentTreeElement

+ func (_m *OrgRepository) Update(tx core.DB, organization *models.Org) error

+ type OrgRepository_ContentTree_Call struct

+ func (_c *OrgRepository_ContentTree_Call) Return(_a0 []obj.ContentTreeElement) *OrgRepository_ContentTree_Call

+ func (_c *OrgRepository_ContentTree_Call) Run(run func(orgID uuid.UUID, projects []string)) *OrgRepository_ContentTree_Call

+ func (_c *OrgRepository_ContentTree_Call) RunAndReturn(run func(uuid.UUID, []string) []obj.ContentTreeElement) *OrgRepository_ContentTree_Call

type OrgRepository_Expecter

+ func (_e *OrgRepository_Expecter) ContentTree(orgID interface{}, projects interface{}) *OrgRepository_ContentTree_Call

+ func (_e *OrgRepository_Expecter) Update(tx interface{}, organization interface{}) *OrgRepository_Update_Call

+ type OrgRepository_Update_Call struct

+ func (_c *OrgRepository_Update_Call) Return(_a0 error) *OrgRepository_Update_Call

+ func (_c *OrgRepository_Update_Call) Run(run func(tx core.DB, organization *models.Org)) *OrgRepository_Update_Call

+ func (_c *OrgRepository_Update_Call) RunAndReturn(run func(core.DB, *models.Org) error) *OrgRepository_Update_Call

+ type ProjectProjectService struct

+ func NewProjectProjectService(t interface{ ... }) *ProjectProjectService

+ func (_m *ProjectProjectService) EXPECT() *ProjectProjectService_Expecter

+ func (_m *ProjectProjectService) ListAllowedProjects(c core.Context) ([]models.Project, error)

+ type ProjectProjectService_Expecter struct

+ func (_e *ProjectProjectService_Expecter) ListAllowedProjects(c interface{}) *ProjectProjectService_ListAllowedProjects_Call

+ type ProjectProjectService_ListAllowedProjects_Call struct

+ func (_c *ProjectProjectService_ListAllowedProjects_Call) Return(_a0 []models.Project, _a1 error) *ProjectProjectService_ListAllowedProjects_Call

+ func (_c *ProjectProjectService_ListAllowedProjects_Call) Run(run func(c core.Context)) *ProjectProjectService_ListAllowedProjects_Call

+ func (_c *ProjectProjectService_ListAllowedProjects_Call) RunAndReturn(run func(core.Context) ([]models.Project, error)) *ProjectProjectService_ListAllowedProjects_Call

+ type ScanAssetRepository struct

+ func NewScanAssetRepository(t interface{ ... }) *ScanAssetRepository

+ func (_m *ScanAssetRepository) EXPECT() *ScanAssetRepository_Expecter

+ func (_m *ScanAssetRepository) GetAllAssetsFromDB() ([]models.Asset, error)

+ func (_m *ScanAssetRepository) Save(tx core.DB, asset *models.Asset) error

+ type ScanAssetRepository_Expecter struct

+ func (_e *ScanAssetRepository_Expecter) GetAllAssetsFromDB() *ScanAssetRepository_GetAllAssetsFromDB_Call

+ func (_e *ScanAssetRepository_Expecter) Save(tx interface{}, asset interface{}) *ScanAssetRepository_Save_Call

+ type ScanAssetRepository_GetAllAssetsFromDB_Call struct

+ func (_c *ScanAssetRepository_GetAllAssetsFromDB_Call) Return(_a0 []models.Asset, _a1 error) *ScanAssetRepository_GetAllAssetsFromDB_Call

+ func (_c *ScanAssetRepository_GetAllAssetsFromDB_Call) Run(run func()) *ScanAssetRepository_GetAllAssetsFromDB_Call

+ func (_c *ScanAssetRepository_GetAllAssetsFromDB_Call) RunAndReturn(run func() ([]models.Asset, error)) *ScanAssetRepository_GetAllAssetsFromDB_Call

+ type ScanAssetRepository_Save_Call struct

+ func (_c *ScanAssetRepository_Save_Call) Return(_a0 error) *ScanAssetRepository_Save_Call

+ func (_c *ScanAssetRepository_Save_Call) Run(run func(tx core.DB, asset *models.Asset)) *ScanAssetRepository_Save_Call

+ func (_c *ScanAssetRepository_Save_Call) RunAndReturn(run func(core.DB, *models.Asset) error) *ScanAssetRepository_Save_Call

type ScanComponentRepository

+ func (_m *ScanComponentRepository) LoadComponents(tx core.DB, asset models.Asset, scanType string, version string) ([]models.ComponentDependency, error)

type ScanComponentRepository_Expecter

+ func (_e *ScanComponentRepository_Expecter) LoadComponents(tx interface{}, asset interface{}, scanType interface{}, version interface{}) *ScanComponentRepository_LoadComponents_Call

+ type ScanComponentRepository_LoadComponents_Call struct

+ func (_c *ScanComponentRepository_LoadComponents_Call) Return(_a0 []models.ComponentDependency, _a1 error) *ScanComponentRepository_LoadComponents_Call

+ func (_c *ScanComponentRepository_LoadComponents_Call) Run(run func(tx core.DB, asset models.Asset, scanType string, version string)) *ScanComponentRepository_LoadComponents_Call

+ func (_c *ScanComponentRepository_LoadComponents_Call) RunAndReturn(...) *ScanComponentRepository_LoadComponents_Call

+ type ScanStatisticsService struct

+ func NewScanStatisticsService(t interface{ ... }) *ScanStatisticsService

+ func (_m *ScanStatisticsService) EXPECT() *ScanStatisticsService_Expecter

+ func (_m *ScanStatisticsService) UpdateAssetRiskAggregation(assetID uuid.UUID, begin time.Time, end time.Time, updateProject bool) error

+ type ScanStatisticsService_Expecter struct

+ func (_e *ScanStatisticsService_Expecter) UpdateAssetRiskAggregation(assetID interface{}, begin interface{}, end interface{}, ...) *ScanStatisticsService_UpdateAssetRiskAggregation_Call

+ type ScanStatisticsService_UpdateAssetRiskAggregation_Call struct

+ func (_c *ScanStatisticsService_UpdateAssetRiskAggregation_Call) Return(_a0 error) *ScanStatisticsService_UpdateAssetRiskAggregation_Call

+ func (_c *ScanStatisticsService_UpdateAssetRiskAggregation_Call) Run(...) *ScanStatisticsService_UpdateAssetRiskAggregation_Call

+ func (_c *ScanStatisticsService_UpdateAssetRiskAggregation_Call) RunAndReturn(run func(uuid.UUID, time.Time, time.Time, bool) error) *ScanStatisticsService_UpdateAssetRiskAggregation_Call

+ type StatisticsAssetRepository struct

+ func NewStatisticsAssetRepository(t interface{ ... }) *StatisticsAssetRepository

+ func (_m *StatisticsAssetRepository) EXPECT() *StatisticsAssetRepository_Expecter

+ func (_m *StatisticsAssetRepository) GetAllAssetsFromDB() ([]models.Asset, error)

+ func (_m *StatisticsAssetRepository) GetByProjectID(projectID uuid.UUID) ([]models.Asset, error)

+ func (_m *StatisticsAssetRepository) Save(tx core.DB, asset *models.Asset) error

+ type StatisticsAssetRepository_Expecter struct

+ func (_e *StatisticsAssetRepository_Expecter) GetAllAssetsFromDB() *StatisticsAssetRepository_GetAllAssetsFromDB_Call

+ func (_e *StatisticsAssetRepository_Expecter) GetByProjectID(projectID interface{}) *StatisticsAssetRepository_GetByProjectID_Call

+ func (_e *StatisticsAssetRepository_Expecter) Save(tx interface{}, asset interface{}) *StatisticsAssetRepository_Save_Call

+ type StatisticsAssetRepository_GetAllAssetsFromDB_Call struct

+ func (_c *StatisticsAssetRepository_GetAllAssetsFromDB_Call) Return(_a0 []models.Asset, _a1 error) *StatisticsAssetRepository_GetAllAssetsFromDB_Call

+ func (_c *StatisticsAssetRepository_GetAllAssetsFromDB_Call) Run(run func()) *StatisticsAssetRepository_GetAllAssetsFromDB_Call

+ func (_c *StatisticsAssetRepository_GetAllAssetsFromDB_Call) RunAndReturn(run func() ([]models.Asset, error)) *StatisticsAssetRepository_GetAllAssetsFromDB_Call

+ type StatisticsAssetRepository_GetByProjectID_Call struct

+ func (_c *StatisticsAssetRepository_GetByProjectID_Call) Return(_a0 []models.Asset, _a1 error) *StatisticsAssetRepository_GetByProjectID_Call

+ func (_c *StatisticsAssetRepository_GetByProjectID_Call) Run(run func(projectID uuid.UUID)) *StatisticsAssetRepository_GetByProjectID_Call

+ func (_c *StatisticsAssetRepository_GetByProjectID_Call) RunAndReturn(run func(uuid.UUID) ([]models.Asset, error)) *StatisticsAssetRepository_GetByProjectID_Call

+ type StatisticsAssetRepository_Save_Call struct

+ func (_c *StatisticsAssetRepository_Save_Call) Return(_a0 error) *StatisticsAssetRepository_Save_Call

+ func (_c *StatisticsAssetRepository_Save_Call) Run(run func(tx core.DB, asset *models.Asset)) *StatisticsAssetRepository_Save_Call

+ func (_c *StatisticsAssetRepository_Save_Call) RunAndReturn(run func(core.DB, *models.Asset) error) *StatisticsAssetRepository_Save_Call

+ type StatisticsAssetRiskHistoryRepository struct

+ func NewStatisticsAssetRiskHistoryRepository(t interface{ ... }) *StatisticsAssetRiskHistoryRepository

+ func (_m *StatisticsAssetRiskHistoryRepository) EXPECT() *StatisticsAssetRiskHistoryRepository_Expecter

+ func (_m *StatisticsAssetRiskHistoryRepository) GetRiskHistory(assetId uuid.UUID, start time.Time, end time.Time) ([]models.AssetRiskHistory, error)

+ func (_m *StatisticsAssetRiskHistoryRepository) GetRiskHistoryByProject(projectId uuid.UUID, day time.Time) ([]models.AssetRiskHistory, error)

+ func (_m *StatisticsAssetRiskHistoryRepository) UpdateRiskAggregation(assetRisk *models.AssetRiskHistory) error

+ type StatisticsAssetRiskHistoryRepository_Expecter struct

+ func (_e *StatisticsAssetRiskHistoryRepository_Expecter) GetRiskHistory(assetId interface{}, start interface{}, end interface{}) *StatisticsAssetRiskHistoryRepository_GetRiskHistory_Call

+ func (_e *StatisticsAssetRiskHistoryRepository_Expecter) GetRiskHistoryByProject(projectId interface{}, day interface{}) *StatisticsAssetRiskHistoryRepository_GetRiskHistoryByProject_Call

+ func (_e *StatisticsAssetRiskHistoryRepository_Expecter) UpdateRiskAggregation(assetRisk interface{}) *StatisticsAssetRiskHistoryRepository_UpdateRiskAggregation_Call

+ type StatisticsAssetRiskHistoryRepository_GetRiskHistoryByProject_Call struct

+ func (_c *StatisticsAssetRiskHistoryRepository_GetRiskHistoryByProject_Call) Return(_a0 []models.AssetRiskHistory, _a1 error) *StatisticsAssetRiskHistoryRepository_GetRiskHistoryByProject_Call

+ func (_c *StatisticsAssetRiskHistoryRepository_GetRiskHistoryByProject_Call) Run(run func(projectId uuid.UUID, day time.Time)) *StatisticsAssetRiskHistoryRepository_GetRiskHistoryByProject_Call

+ func (_c *StatisticsAssetRiskHistoryRepository_GetRiskHistoryByProject_Call) RunAndReturn(run func(uuid.UUID, time.Time) ([]models.AssetRiskHistory, error)) *StatisticsAssetRiskHistoryRepository_GetRiskHistoryByProject_Call

+ type StatisticsAssetRiskHistoryRepository_GetRiskHistory_Call struct

+ func (_c *StatisticsAssetRiskHistoryRepository_GetRiskHistory_Call) Return(_a0 []models.AssetRiskHistory, _a1 error) *StatisticsAssetRiskHistoryRepository_GetRiskHistory_Call

+ func (_c *StatisticsAssetRiskHistoryRepository_GetRiskHistory_Call) Run(run func(assetId uuid.UUID, start time.Time, end time.Time)) *StatisticsAssetRiskHistoryRepository_GetRiskHistory_Call

+ func (_c *StatisticsAssetRiskHistoryRepository_GetRiskHistory_Call) RunAndReturn(run func(uuid.UUID, time.Time, time.Time) ([]models.AssetRiskHistory, error)) *StatisticsAssetRiskHistoryRepository_GetRiskHistory_Call

+ type StatisticsAssetRiskHistoryRepository_UpdateRiskAggregation_Call struct

+ func (_c *StatisticsAssetRiskHistoryRepository_UpdateRiskAggregation_Call) Return(_a0 error) *StatisticsAssetRiskHistoryRepository_UpdateRiskAggregation_Call

+ func (_c *StatisticsAssetRiskHistoryRepository_UpdateRiskAggregation_Call) Run(run func(assetRisk *models.AssetRiskHistory)) *StatisticsAssetRiskHistoryRepository_UpdateRiskAggregation_Call

+ func (_c *StatisticsAssetRiskHistoryRepository_UpdateRiskAggregation_Call) RunAndReturn(run func(*models.AssetRiskHistory) error) *StatisticsAssetRiskHistoryRepository_UpdateRiskAggregation_Call

+ type StatisticsAssetToProjectIdConverter struct

+ func NewStatisticsAssetToProjectIdConverter(t interface{ ... }) *StatisticsAssetToProjectIdConverter

+ func (_m *StatisticsAssetToProjectIdConverter) EXPECT() *StatisticsAssetToProjectIdConverter_Expecter

+ func (_m *StatisticsAssetToProjectIdConverter) GetProjectIdByAssetID(assetID uuid.UUID) (uuid.UUID, error)

+ type StatisticsAssetToProjectIdConverter_Expecter struct

+ func (_e *StatisticsAssetToProjectIdConverter_Expecter) GetProjectIdByAssetID(assetID interface{}) *StatisticsAssetToProjectIdConverter_GetProjectIdByAssetID_Call

+ type StatisticsAssetToProjectIdConverter_GetProjectIdByAssetID_Call struct

+ func (_c *StatisticsAssetToProjectIdConverter_GetProjectIdByAssetID_Call) Return(_a0 uuid.UUID, _a1 error) *StatisticsAssetToProjectIdConverter_GetProjectIdByAssetID_Call

+ func (_c *StatisticsAssetToProjectIdConverter_GetProjectIdByAssetID_Call) Run(run func(assetID uuid.UUID)) *StatisticsAssetToProjectIdConverter_GetProjectIdByAssetID_Call

+ func (_c *StatisticsAssetToProjectIdConverter_GetProjectIdByAssetID_Call) RunAndReturn(run func(uuid.UUID) (uuid.UUID, error)) *StatisticsAssetToProjectIdConverter_GetProjectIdByAssetID_Call

+ type StatisticsComponentRepository struct

+ func NewStatisticsComponentRepository(t interface{ ... }) *StatisticsComponentRepository

+ func (_m *StatisticsComponentRepository) EXPECT() *StatisticsComponentRepository_Expecter

+ func (_m *StatisticsComponentRepository) GetDependencyCountPerScanType(assetID uuid.UUID) (map[string]int, error)

+ type StatisticsComponentRepository_Expecter struct

+ func (_e *StatisticsComponentRepository_Expecter) GetDependencyCountPerScanType(assetID interface{}) *StatisticsComponentRepository_GetDependencyCountPerScanType_Call

+ type StatisticsComponentRepository_GetDependencyCountPerScanType_Call struct

+ func (_c *StatisticsComponentRepository_GetDependencyCountPerScanType_Call) Return(_a0 map[string]int, _a1 error) *StatisticsComponentRepository_GetDependencyCountPerScanType_Call

+ func (_c *StatisticsComponentRepository_GetDependencyCountPerScanType_Call) Run(run func(assetID uuid.UUID)) *StatisticsComponentRepository_GetDependencyCountPerScanType_Call

+ func (_c *StatisticsComponentRepository_GetDependencyCountPerScanType_Call) RunAndReturn(run func(uuid.UUID) (map[string]int, error)) *StatisticsComponentRepository_GetDependencyCountPerScanType_Call

+ type StatisticsFlawRepository struct

+ func NewStatisticsFlawRepository(t interface{ ... }) *StatisticsFlawRepository

+ func (_m *StatisticsFlawRepository) EXPECT() *StatisticsFlawRepository_Expecter

+ func (_m *StatisticsFlawRepository) GetAllFlawsByAssetID(tx core.DB, assetID uuid.UUID) ([]models.Flaw, error)

+ func (_m *StatisticsFlawRepository) GetAllOpenFlawsByAssetID(tx core.DB, assetID uuid.UUID) ([]models.Flaw, error)

+ type StatisticsFlawRepository_Expecter struct

+ func (_e *StatisticsFlawRepository_Expecter) GetAllFlawsByAssetID(tx interface{}, assetID interface{}) *StatisticsFlawRepository_GetAllFlawsByAssetID_Call

+ func (_e *StatisticsFlawRepository_Expecter) GetAllOpenFlawsByAssetID(tx interface{}, assetID interface{}) *StatisticsFlawRepository_GetAllOpenFlawsByAssetID_Call

+ type StatisticsFlawRepository_GetAllFlawsByAssetID_Call struct

+ func (_c *StatisticsFlawRepository_GetAllFlawsByAssetID_Call) Return(_a0 []models.Flaw, _a1 error) *StatisticsFlawRepository_GetAllFlawsByAssetID_Call

+ func (_c *StatisticsFlawRepository_GetAllFlawsByAssetID_Call) Run(run func(tx core.DB, assetID uuid.UUID)) *StatisticsFlawRepository_GetAllFlawsByAssetID_Call

+ func (_c *StatisticsFlawRepository_GetAllFlawsByAssetID_Call) RunAndReturn(run func(core.DB, uuid.UUID) ([]models.Flaw, error)) *StatisticsFlawRepository_GetAllFlawsByAssetID_Call

+ type StatisticsFlawRepository_GetAllOpenFlawsByAssetID_Call struct

+ func (_c *StatisticsFlawRepository_GetAllOpenFlawsByAssetID_Call) Return(_a0 []models.Flaw, _a1 error) *StatisticsFlawRepository_GetAllOpenFlawsByAssetID_Call

+ func (_c *StatisticsFlawRepository_GetAllOpenFlawsByAssetID_Call) Run(run func(tx core.DB, assetID uuid.UUID)) *StatisticsFlawRepository_GetAllOpenFlawsByAssetID_Call

+ func (_c *StatisticsFlawRepository_GetAllOpenFlawsByAssetID_Call) RunAndReturn(run func(core.DB, uuid.UUID) ([]models.Flaw, error)) *StatisticsFlawRepository_GetAllOpenFlawsByAssetID_Call

+ type StatisticsProjectRepository struct

+ func NewStatisticsProjectRepository(t interface{ ... }) *StatisticsProjectRepository

+ func (_m *StatisticsProjectRepository) EXPECT() *StatisticsProjectRepository_Expecter

+ func (_m *StatisticsProjectRepository) GetByOrgID(organizationID uuid.UUID) ([]models.Project, error)

+ type StatisticsProjectRepository_Expecter struct

+ func (_e *StatisticsProjectRepository_Expecter) GetByOrgID(organizationID interface{}) *StatisticsProjectRepository_GetByOrgID_Call

+ type StatisticsProjectRepository_GetByOrgID_Call struct

+ func (_c *StatisticsProjectRepository_GetByOrgID_Call) Return(_a0 []models.Project, _a1 error) *StatisticsProjectRepository_GetByOrgID_Call

+ func (_c *StatisticsProjectRepository_GetByOrgID_Call) Run(run func(organizationID uuid.UUID)) *StatisticsProjectRepository_GetByOrgID_Call

+ func (_c *StatisticsProjectRepository_GetByOrgID_Call) RunAndReturn(run func(uuid.UUID) ([]models.Project, error)) *StatisticsProjectRepository_GetByOrgID_Call

+ type StatisticsProjectRiskHistoryRepository struct

+ func NewStatisticsProjectRiskHistoryRepository(t interface{ ... }) *StatisticsProjectRiskHistoryRepository

+ func (_m *StatisticsProjectRiskHistoryRepository) EXPECT() *StatisticsProjectRiskHistoryRepository_Expecter

+ func (_m *StatisticsProjectRiskHistoryRepository) GetRiskHistory(projectId uuid.UUID, start time.Time, end time.Time) ([]models.ProjectRiskHistory, error)

+ func (_m *StatisticsProjectRiskHistoryRepository) UpdateRiskAggregation(projectRisk *models.ProjectRiskHistory) error

+ type StatisticsProjectRiskHistoryRepository_Expecter struct

+ func (_e *StatisticsProjectRiskHistoryRepository_Expecter) GetRiskHistory(projectId interface{}, start interface{}, end interface{}) *StatisticsProjectRiskHistoryRepository_GetRiskHistory_Call

+ func (_e *StatisticsProjectRiskHistoryRepository_Expecter) UpdateRiskAggregation(projectRisk interface{}) *StatisticsProjectRiskHistoryRepository_UpdateRiskAggregation_Call

+ type StatisticsProjectRiskHistoryRepository_GetRiskHistory_Call struct

+ func (_c *StatisticsProjectRiskHistoryRepository_GetRiskHistory_Call) Return(_a0 []models.ProjectRiskHistory, _a1 error) *StatisticsProjectRiskHistoryRepository_GetRiskHistory_Call

+ func (_c *StatisticsProjectRiskHistoryRepository_GetRiskHistory_Call) Run(run func(projectId uuid.UUID, start time.Time, end time.Time)) *StatisticsProjectRiskHistoryRepository_GetRiskHistory_Call

+ func (_c *StatisticsProjectRiskHistoryRepository_GetRiskHistory_Call) RunAndReturn(run func(uuid.UUID, time.Time, time.Time) ([]models.ProjectRiskHistory, error)) *StatisticsProjectRiskHistoryRepository_GetRiskHistory_Call

+ type StatisticsProjectRiskHistoryRepository_UpdateRiskAggregation_Call struct

+ func (_c *StatisticsProjectRiskHistoryRepository_UpdateRiskAggregation_Call) Return(_a0 error) *StatisticsProjectRiskHistoryRepository_UpdateRiskAggregation_Call

+ func (_c *StatisticsProjectRiskHistoryRepository_UpdateRiskAggregation_Call) Run(run func(projectRisk *models.ProjectRiskHistory)) *StatisticsProjectRiskHistoryRepository_UpdateRiskAggregation_Call

+ func (_c *StatisticsProjectRiskHistoryRepository_UpdateRiskAggregation_Call) RunAndReturn(run func(*models.ProjectRiskHistory) error) *StatisticsProjectRiskHistoryRepository_UpdateRiskAggregation_Call

+ type StatisticsProjectService struct

+ func NewStatisticsProjectService(t interface{ ... }) *StatisticsProjectService

+ func (_m *StatisticsProjectService) EXPECT() *StatisticsProjectService_Expecter

+ func (_m *StatisticsProjectService) ListAllowedProjects(c core.Context) ([]models.Project, error)

+ type StatisticsProjectService_Expecter struct

+ func (_e *StatisticsProjectService_Expecter) ListAllowedProjects(c interface{}) *StatisticsProjectService_ListAllowedProjects_Call

+ type StatisticsProjectService_ListAllowedProjects_Call struct

+ func (_c *StatisticsProjectService_ListAllowedProjects_Call) Return(_a0 []models.Project, _a1 error) *StatisticsProjectService_ListAllowedProjects_Call

+ func (_c *StatisticsProjectService_ListAllowedProjects_Call) Run(run func(c core.Context)) *StatisticsProjectService_ListAllowedProjects_Call

+ func (_c *StatisticsProjectService_ListAllowedProjects_Call) RunAndReturn(run func(core.Context) ([]models.Project, error)) *StatisticsProjectService_ListAllowedProjects_Call

+ type StatisticsStatisticsRepository struct

+ func NewStatisticsStatisticsRepository(t interface{ ... }) *StatisticsStatisticsRepository

+ func (_m *StatisticsStatisticsRepository) AverageFixingTime(assetID uuid.UUID, riskIntervalStart float64, riskIntervalEnd float64) (time.Duration, error)

+ func (_m *StatisticsStatisticsRepository) EXPECT() *StatisticsStatisticsRepository_Expecter

+ func (_m *StatisticsStatisticsRepository) GetAssetRiskDistribution(assetID uuid.UUID, assetName string) (models.AssetRiskDistribution, error)

+ func (_m *StatisticsStatisticsRepository) GetFlawCountByScannerId(assetID uuid.UUID) (map[string]int, error)

+ func (_m *StatisticsStatisticsRepository) TimeTravelFlawState(assetID uuid.UUID, _a1 time.Time) ([]models.Flaw, error)

+ type StatisticsStatisticsRepository_AverageFixingTime_Call struct

+ func (_c *StatisticsStatisticsRepository_AverageFixingTime_Call) Return(_a0 time.Duration, _a1 error) *StatisticsStatisticsRepository_AverageFixingTime_Call

+ func (_c *StatisticsStatisticsRepository_AverageFixingTime_Call) Run(...) *StatisticsStatisticsRepository_AverageFixingTime_Call

+ func (_c *StatisticsStatisticsRepository_AverageFixingTime_Call) RunAndReturn(run func(uuid.UUID, float64, float64) (time.Duration, error)) *StatisticsStatisticsRepository_AverageFixingTime_Call

+ type StatisticsStatisticsRepository_Expecter struct

+ func (_e *StatisticsStatisticsRepository_Expecter) AverageFixingTime(assetID interface{}, riskIntervalStart interface{}, ...) *StatisticsStatisticsRepository_AverageFixingTime_Call

+ func (_e *StatisticsStatisticsRepository_Expecter) GetAssetRiskDistribution(assetID interface{}, assetName interface{}) *StatisticsStatisticsRepository_GetAssetRiskDistribution_Call

+ func (_e *StatisticsStatisticsRepository_Expecter) GetFlawCountByScannerId(assetID interface{}) *StatisticsStatisticsRepository_GetFlawCountByScannerId_Call

+ func (_e *StatisticsStatisticsRepository_Expecter) TimeTravelFlawState(assetID interface{}, _a1 interface{}) *StatisticsStatisticsRepository_TimeTravelFlawState_Call

+ type StatisticsStatisticsRepository_GetAssetRiskDistribution_Call struct

+ func (_c *StatisticsStatisticsRepository_GetAssetRiskDistribution_Call) Return(_a0 models.AssetRiskDistribution, _a1 error) *StatisticsStatisticsRepository_GetAssetRiskDistribution_Call

+ func (_c *StatisticsStatisticsRepository_GetAssetRiskDistribution_Call) Run(run func(assetID uuid.UUID, assetName string)) *StatisticsStatisticsRepository_GetAssetRiskDistribution_Call

+ func (_c *StatisticsStatisticsRepository_GetAssetRiskDistribution_Call) RunAndReturn(run func(uuid.UUID, string) (models.AssetRiskDistribution, error)) *StatisticsStatisticsRepository_GetAssetRiskDistribution_Call

+ type StatisticsStatisticsRepository_GetFlawCountByScannerId_Call struct

+ func (_c *StatisticsStatisticsRepository_GetFlawCountByScannerId_Call) Return(_a0 map[string]int, _a1 error) *StatisticsStatisticsRepository_GetFlawCountByScannerId_Call

+ func (_c *StatisticsStatisticsRepository_GetFlawCountByScannerId_Call) Run(run func(assetID uuid.UUID)) *StatisticsStatisticsRepository_GetFlawCountByScannerId_Call

+ func (_c *StatisticsStatisticsRepository_GetFlawCountByScannerId_Call) RunAndReturn(run func(uuid.UUID) (map[string]int, error)) *StatisticsStatisticsRepository_GetFlawCountByScannerId_Call

+ type StatisticsStatisticsRepository_TimeTravelFlawState_Call struct

+ func (_c *StatisticsStatisticsRepository_TimeTravelFlawState_Call) Return(_a0 []models.Flaw, _a1 error) *StatisticsStatisticsRepository_TimeTravelFlawState_Call

+ func (_c *StatisticsStatisticsRepository_TimeTravelFlawState_Call) Run(run func(assetID uuid.UUID, _a1 time.Time)) *StatisticsStatisticsRepository_TimeTravelFlawState_Call

+ func (_c *StatisticsStatisticsRepository_TimeTravelFlawState_Call) RunAndReturn(run func(uuid.UUID, time.Time) ([]models.Flaw, error)) *StatisticsStatisticsRepository_TimeTravelFlawState_Call

+ type StatisticsStatisticsService struct

+ func NewStatisticsStatisticsService(t interface{ ... }) *StatisticsStatisticsService

+ func (_m *StatisticsStatisticsService) EXPECT() *StatisticsStatisticsService_Expecter

+ func (_m *StatisticsStatisticsService) GetAssetRiskDistribution(assetID uuid.UUID, assetName string) (models.AssetRiskDistribution, error)

+ func (_m *StatisticsStatisticsService) GetAssetRiskHistory(assetID uuid.UUID, start time.Time, end time.Time) ([]models.AssetRiskHistory, error)

+ func (_m *StatisticsStatisticsService) GetAverageFixingTime(assetID uuid.UUID, severity string) (time.Duration, error)

+ func (_m *StatisticsStatisticsService) GetComponentRisk(assetID uuid.UUID) (map[string]float64, error)

+ func (_m *StatisticsStatisticsService) GetDependencyCountPerScanType(assetID uuid.UUID) (map[string]int, error)

+ func (_m *StatisticsStatisticsService) GetFlawAggregationStateAndChangeSince(assetID uuid.UUID, calculateChangeTo time.Time) (statistics.FlawAggregationStateAndChange, error)

+ func (_m *StatisticsStatisticsService) GetFlawCountByScannerId(assetID uuid.UUID) (map[string]int, error)

+ func (_m *StatisticsStatisticsService) GetProjectRiskHistory(projectID uuid.UUID, start time.Time, end time.Time) ([]models.ProjectRiskHistory, error)

+ func (_m *StatisticsStatisticsService) UpdateAssetRiskAggregation(assetID uuid.UUID, start time.Time, end time.Time, updateProject bool) error

+ type StatisticsStatisticsService_Expecter struct

+ func (_e *StatisticsStatisticsService_Expecter) GetAssetRiskDistribution(assetID interface{}, assetName interface{}) *StatisticsStatisticsService_GetAssetRiskDistribution_Call

+ func (_e *StatisticsStatisticsService_Expecter) GetAssetRiskHistory(assetID interface{}, start interface{}, end interface{}) *StatisticsStatisticsService_GetAssetRiskHistory_Call

+ func (_e *StatisticsStatisticsService_Expecter) GetAverageFixingTime(assetID interface{}, severity interface{}) *StatisticsStatisticsService_GetAverageFixingTime_Call

+ func (_e *StatisticsStatisticsService_Expecter) GetComponentRisk(assetID interface{}) *StatisticsStatisticsService_GetComponentRisk_Call

+ func (_e *StatisticsStatisticsService_Expecter) GetDependencyCountPerScanType(assetID interface{}) *StatisticsStatisticsService_GetDependencyCountPerScanType_Call

+ func (_e *StatisticsStatisticsService_Expecter) GetFlawAggregationStateAndChangeSince(assetID interface{}, calculateChangeTo interface{}) *StatisticsStatisticsService_GetFlawAggregationStateAndChangeSince_Call

+ func (_e *StatisticsStatisticsService_Expecter) GetFlawCountByScannerId(assetID interface{}) *StatisticsStatisticsService_GetFlawCountByScannerId_Call

+ func (_e *StatisticsStatisticsService_Expecter) GetProjectRiskHistory(projectID interface{}, start interface{}, end interface{}) *StatisticsStatisticsService_GetProjectRiskHistory_Call

+ func (_e *StatisticsStatisticsService_Expecter) UpdateAssetRiskAggregation(assetID interface{}, start interface{}, end interface{}, ...) *StatisticsStatisticsService_UpdateAssetRiskAggregation_Call

+ type StatisticsStatisticsService_GetAssetRiskDistribution_Call struct

+ func (_c *StatisticsStatisticsService_GetAssetRiskDistribution_Call) Return(_a0 models.AssetRiskDistribution, _a1 error) *StatisticsStatisticsService_GetAssetRiskDistribution_Call

+ func (_c *StatisticsStatisticsService_GetAssetRiskDistribution_Call) Run(run func(assetID uuid.UUID, assetName string)) *StatisticsStatisticsService_GetAssetRiskDistribution_Call

+ func (_c *StatisticsStatisticsService_GetAssetRiskDistribution_Call) RunAndReturn(run func(uuid.UUID, string) (models.AssetRiskDistribution, error)) *StatisticsStatisticsService_GetAssetRiskDistribution_Call

+ type StatisticsStatisticsService_GetAssetRiskHistory_Call struct

+ func (_c *StatisticsStatisticsService_GetAssetRiskHistory_Call) Return(_a0 []models.AssetRiskHistory, _a1 error) *StatisticsStatisticsService_GetAssetRiskHistory_Call

+ func (_c *StatisticsStatisticsService_GetAssetRiskHistory_Call) Run(run func(assetID uuid.UUID, start time.Time, end time.Time)) *StatisticsStatisticsService_GetAssetRiskHistory_Call

+ func (_c *StatisticsStatisticsService_GetAssetRiskHistory_Call) RunAndReturn(run func(uuid.UUID, time.Time, time.Time) ([]models.AssetRiskHistory, error)) *StatisticsStatisticsService_GetAssetRiskHistory_Call

+ type StatisticsStatisticsService_GetAverageFixingTime_Call struct

+ func (_c *StatisticsStatisticsService_GetAverageFixingTime_Call) Return(_a0 time.Duration, _a1 error) *StatisticsStatisticsService_GetAverageFixingTime_Call

+ func (_c *StatisticsStatisticsService_GetAverageFixingTime_Call) Run(run func(assetID uuid.UUID, severity string)) *StatisticsStatisticsService_GetAverageFixingTime_Call

+ func (_c *StatisticsStatisticsService_GetAverageFixingTime_Call) RunAndReturn(run func(uuid.UUID, string) (time.Duration, error)) *StatisticsStatisticsService_GetAverageFixingTime_Call

+ type StatisticsStatisticsService_GetComponentRisk_Call struct

+ func (_c *StatisticsStatisticsService_GetComponentRisk_Call) Return(_a0 map[string]float64, _a1 error) *StatisticsStatisticsService_GetComponentRisk_Call

+ func (_c *StatisticsStatisticsService_GetComponentRisk_Call) Run(run func(assetID uuid.UUID)) *StatisticsStatisticsService_GetComponentRisk_Call

+ func (_c *StatisticsStatisticsService_GetComponentRisk_Call) RunAndReturn(run func(uuid.UUID) (map[string]float64, error)) *StatisticsStatisticsService_GetComponentRisk_Call

+ type StatisticsStatisticsService_GetDependencyCountPerScanType_Call struct

+ func (_c *StatisticsStatisticsService_GetDependencyCountPerScanType_Call) Return(_a0 map[string]int, _a1 error) *StatisticsStatisticsService_GetDependencyCountPerScanType_Call

+ func (_c *StatisticsStatisticsService_GetDependencyCountPerScanType_Call) Run(run func(assetID uuid.UUID)) *StatisticsStatisticsService_GetDependencyCountPerScanType_Call

+ func (_c *StatisticsStatisticsService_GetDependencyCountPerScanType_Call) RunAndReturn(run func(uuid.UUID) (map[string]int, error)) *StatisticsStatisticsService_GetDependencyCountPerScanType_Call

+ type StatisticsStatisticsService_GetFlawAggregationStateAndChangeSince_Call struct

+ func (_c *StatisticsStatisticsService_GetFlawAggregationStateAndChangeSince_Call) Return(_a0 statistics.FlawAggregationStateAndChange, _a1 error) *StatisticsStatisticsService_GetFlawAggregationStateAndChangeSince_Call

+ func (_c *StatisticsStatisticsService_GetFlawAggregationStateAndChangeSince_Call) Run(run func(assetID uuid.UUID, calculateChangeTo time.Time)) *StatisticsStatisticsService_GetFlawAggregationStateAndChangeSince_Call

+ func (_c *StatisticsStatisticsService_GetFlawAggregationStateAndChangeSince_Call) RunAndReturn(...) *StatisticsStatisticsService_GetFlawAggregationStateAndChangeSince_Call

+ type StatisticsStatisticsService_GetFlawCountByScannerId_Call struct

+ func (_c *StatisticsStatisticsService_GetFlawCountByScannerId_Call) Return(_a0 map[string]int, _a1 error) *StatisticsStatisticsService_GetFlawCountByScannerId_Call

+ func (_c *StatisticsStatisticsService_GetFlawCountByScannerId_Call) Run(run func(assetID uuid.UUID)) *StatisticsStatisticsService_GetFlawCountByScannerId_Call

+ func (_c *StatisticsStatisticsService_GetFlawCountByScannerId_Call) RunAndReturn(run func(uuid.UUID) (map[string]int, error)) *StatisticsStatisticsService_GetFlawCountByScannerId_Call

+ type StatisticsStatisticsService_GetProjectRiskHistory_Call struct

+ func (_c *StatisticsStatisticsService_GetProjectRiskHistory_Call) Return(_a0 []models.ProjectRiskHistory, _a1 error) *StatisticsStatisticsService_GetProjectRiskHistory_Call

+ func (_c *StatisticsStatisticsService_GetProjectRiskHistory_Call) Run(run func(projectID uuid.UUID, start time.Time, end time.Time)) *StatisticsStatisticsService_GetProjectRiskHistory_Call

+ func (_c *StatisticsStatisticsService_GetProjectRiskHistory_Call) RunAndReturn(run func(uuid.UUID, time.Time, time.Time) ([]models.ProjectRiskHistory, error)) *StatisticsStatisticsService_GetProjectRiskHistory_Call

+ type StatisticsStatisticsService_UpdateAssetRiskAggregation_Call struct

+ func (_c *StatisticsStatisticsService_UpdateAssetRiskAggregation_Call) Return(_a0 error) *StatisticsStatisticsService_UpdateAssetRiskAggregation_Call

+ func (_c *StatisticsStatisticsService_UpdateAssetRiskAggregation_Call) Run(...) *StatisticsStatisticsService_UpdateAssetRiskAggregation_Call

+ func (_c *StatisticsStatisticsService_UpdateAssetRiskAggregation_Call) RunAndReturn(run func(uuid.UUID, time.Time, time.Time, bool) error) *StatisticsStatisticsService_UpdateAssetRiskAggregation_Call

+ type VulndbAffectedComponentsRepository struct

+ func NewVulndbAffectedComponentsRepository(t interface{ ... }) *VulndbAffectedComponentsRepository

+ func (_m *VulndbAffectedComponentsRepository) EXPECT() *VulndbAffectedComponentsRepository_Expecter

+ func (_m *VulndbAffectedComponentsRepository) GetAllAffectedComponentsID() ([]string, error)

+ func (_m *VulndbAffectedComponentsRepository) Save(tx database.DB, affectedComponent *models.AffectedComponent) error

+ func (_m *VulndbAffectedComponentsRepository) SaveBatch(tx core.DB, affectedPkgs []models.AffectedComponent) error

+ type VulndbAffectedComponentsRepository_Expecter struct

+ func (_e *VulndbAffectedComponentsRepository_Expecter) GetAllAffectedComponentsID() *VulndbAffectedComponentsRepository_GetAllAffectedComponentsID_Call

+ func (_e *VulndbAffectedComponentsRepository_Expecter) Save(tx interface{}, affectedComponent interface{}) *VulndbAffectedComponentsRepository_Save_Call

+ func (_e *VulndbAffectedComponentsRepository_Expecter) SaveBatch(tx interface{}, affectedPkgs interface{}) *VulndbAffectedComponentsRepository_SaveBatch_Call

+ type VulndbAffectedComponentsRepository_GetAllAffectedComponentsID_Call struct

+ func (_c *VulndbAffectedComponentsRepository_GetAllAffectedComponentsID_Call) Return(_a0 []string, _a1 error) *VulndbAffectedComponentsRepository_GetAllAffectedComponentsID_Call

+ func (_c *VulndbAffectedComponentsRepository_GetAllAffectedComponentsID_Call) Run(run func()) *VulndbAffectedComponentsRepository_GetAllAffectedComponentsID_Call

+ func (_c *VulndbAffectedComponentsRepository_GetAllAffectedComponentsID_Call) RunAndReturn(run func() ([]string, error)) *VulndbAffectedComponentsRepository_GetAllAffectedComponentsID_Call

+ type VulndbAffectedComponentsRepository_SaveBatch_Call struct

+ func (_c *VulndbAffectedComponentsRepository_SaveBatch_Call) Return(_a0 error) *VulndbAffectedComponentsRepository_SaveBatch_Call

+ func (_c *VulndbAffectedComponentsRepository_SaveBatch_Call) Run(run func(tx core.DB, affectedPkgs []models.AffectedComponent)) *VulndbAffectedComponentsRepository_SaveBatch_Call

+ func (_c *VulndbAffectedComponentsRepository_SaveBatch_Call) RunAndReturn(run func(core.DB, []models.AffectedComponent) error) *VulndbAffectedComponentsRepository_SaveBatch_Call

+ type VulndbAffectedComponentsRepository_Save_Call struct

+ func (_c *VulndbAffectedComponentsRepository_Save_Call) Return(_a0 error) *VulndbAffectedComponentsRepository_Save_Call

+ func (_c *VulndbAffectedComponentsRepository_Save_Call) Run(run func(tx database.DB, affectedComponent *models.AffectedComponent)) *VulndbAffectedComponentsRepository_Save_Call

+ func (_c *VulndbAffectedComponentsRepository_Save_Call) RunAndReturn(run func(database.DB, *models.AffectedComponent) error) *VulndbAffectedComponentsRepository_Save_Call

+ type VulndbCvesRepository struct

+ func NewVulndbCvesRepository(t interface{ ... }) *VulndbCvesRepository

+ func (_m *VulndbCvesRepository) Begin() database.DB

+ func (_m *VulndbCvesRepository) Create(tx database.DB, t *models.CVE) error

+ func (_m *VulndbCvesRepository) CreateBatch(tx database.DB, ts []models.CVE) error

+ func (_m *VulndbCvesRepository) Delete(tx database.DB, id string) error

+ func (_m *VulndbCvesRepository) EXPECT() *VulndbCvesRepository_Expecter

+ func (_m *VulndbCvesRepository) GetAllCPEMatchesID() ([]string, error)

+ func (_m *VulndbCvesRepository) GetAllCVEsID() ([]string, error)

+ func (_m *VulndbCvesRepository) GetDB(tx database.DB) database.DB

+ func (_m *VulndbCvesRepository) List(ids []string) ([]models.CVE, error)

+ func (_m *VulndbCvesRepository) Read(id string) (models.CVE, error)

+ func (_m *VulndbCvesRepository) Save(tx database.DB, cve *models.CVE) error

+ func (_m *VulndbCvesRepository) SaveBatch(tx database.DB, ts []models.CVE) error

+ func (_m *VulndbCvesRepository) SaveBatchCPEMatch(tx database.DB, matches []models.CPEMatch) error

+ func (_m *VulndbCvesRepository) SaveCveAffectedComponents(tx core.DB, cveId string, affectedComponentHashes []string) error

+ func (_m *VulndbCvesRepository) Transaction(_a0 func(database.DB) error) error

+ type VulndbCvesRepository_Begin_Call struct

+ func (_c *VulndbCvesRepository_Begin_Call) Return(_a0 database.DB) *VulndbCvesRepository_Begin_Call

+ func (_c *VulndbCvesRepository_Begin_Call) Run(run func()) *VulndbCvesRepository_Begin_Call

+ func (_c *VulndbCvesRepository_Begin_Call) RunAndReturn(run func() database.DB) *VulndbCvesRepository_Begin_Call

+ type VulndbCvesRepository_CreateBatch_Call struct

+ func (_c *VulndbCvesRepository_CreateBatch_Call) Return(_a0 error) *VulndbCvesRepository_CreateBatch_Call

+ func (_c *VulndbCvesRepository_CreateBatch_Call) Run(run func(tx database.DB, ts []models.CVE)) *VulndbCvesRepository_CreateBatch_Call

+ func (_c *VulndbCvesRepository_CreateBatch_Call) RunAndReturn(run func(database.DB, []models.CVE) error) *VulndbCvesRepository_CreateBatch_Call

+ type VulndbCvesRepository_Create_Call struct

+ func (_c *VulndbCvesRepository_Create_Call) Return(_a0 error) *VulndbCvesRepository_Create_Call

+ func (_c *VulndbCvesRepository_Create_Call) Run(run func(tx database.DB, t *models.CVE)) *VulndbCvesRepository_Create_Call

+ func (_c *VulndbCvesRepository_Create_Call) RunAndReturn(run func(database.DB, *models.CVE) error) *VulndbCvesRepository_Create_Call

+ type VulndbCvesRepository_Delete_Call struct

+ func (_c *VulndbCvesRepository_Delete_Call) Return(_a0 error) *VulndbCvesRepository_Delete_Call

+ func (_c *VulndbCvesRepository_Delete_Call) Run(run func(tx database.DB, id string)) *VulndbCvesRepository_Delete_Call

+ func (_c *VulndbCvesRepository_Delete_Call) RunAndReturn(run func(database.DB, string) error) *VulndbCvesRepository_Delete_Call

+ type VulndbCvesRepository_Expecter struct

+ func (_e *VulndbCvesRepository_Expecter) Begin() *VulndbCvesRepository_Begin_Call

+ func (_e *VulndbCvesRepository_Expecter) Create(tx interface{}, t interface{}) *VulndbCvesRepository_Create_Call

+ func (_e *VulndbCvesRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *VulndbCvesRepository_CreateBatch_Call

+ func (_e *VulndbCvesRepository_Expecter) Delete(tx interface{}, id interface{}) *VulndbCvesRepository_Delete_Call

+ func (_e *VulndbCvesRepository_Expecter) GetAllCPEMatchesID() *VulndbCvesRepository_GetAllCPEMatchesID_Call

+ func (_e *VulndbCvesRepository_Expecter) GetAllCVEsID() *VulndbCvesRepository_GetAllCVEsID_Call

+ func (_e *VulndbCvesRepository_Expecter) GetDB(tx interface{}) *VulndbCvesRepository_GetDB_Call

+ func (_e *VulndbCvesRepository_Expecter) List(ids interface{}) *VulndbCvesRepository_List_Call

+ func (_e *VulndbCvesRepository_Expecter) Read(id interface{}) *VulndbCvesRepository_Read_Call

+ func (_e *VulndbCvesRepository_Expecter) Save(tx interface{}, cve interface{}) *VulndbCvesRepository_Save_Call

+ func (_e *VulndbCvesRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *VulndbCvesRepository_SaveBatch_Call

+ func (_e *VulndbCvesRepository_Expecter) SaveBatchCPEMatch(tx interface{}, matches interface{}) *VulndbCvesRepository_SaveBatchCPEMatch_Call

+ func (_e *VulndbCvesRepository_Expecter) SaveCveAffectedComponents(tx interface{}, cveId interface{}, affectedComponentHashes interface{}) *VulndbCvesRepository_SaveCveAffectedComponents_Call

+ func (_e *VulndbCvesRepository_Expecter) Transaction(_a0 interface{}) *VulndbCvesRepository_Transaction_Call

+ type VulndbCvesRepository_GetAllCPEMatchesID_Call struct

+ func (_c *VulndbCvesRepository_GetAllCPEMatchesID_Call) Return(_a0 []string, _a1 error) *VulndbCvesRepository_GetAllCPEMatchesID_Call

+ func (_c *VulndbCvesRepository_GetAllCPEMatchesID_Call) Run(run func()) *VulndbCvesRepository_GetAllCPEMatchesID_Call

+ func (_c *VulndbCvesRepository_GetAllCPEMatchesID_Call) RunAndReturn(run func() ([]string, error)) *VulndbCvesRepository_GetAllCPEMatchesID_Call

+ type VulndbCvesRepository_GetAllCVEsID_Call struct

+ func (_c *VulndbCvesRepository_GetAllCVEsID_Call) Return(_a0 []string, _a1 error) *VulndbCvesRepository_GetAllCVEsID_Call

+ func (_c *VulndbCvesRepository_GetAllCVEsID_Call) Run(run func()) *VulndbCvesRepository_GetAllCVEsID_Call

+ func (_c *VulndbCvesRepository_GetAllCVEsID_Call) RunAndReturn(run func() ([]string, error)) *VulndbCvesRepository_GetAllCVEsID_Call

+ type VulndbCvesRepository_GetDB_Call struct

+ func (_c *VulndbCvesRepository_GetDB_Call) Return(_a0 database.DB) *VulndbCvesRepository_GetDB_Call

+ func (_c *VulndbCvesRepository_GetDB_Call) Run(run func(tx database.DB)) *VulndbCvesRepository_GetDB_Call

+ func (_c *VulndbCvesRepository_GetDB_Call) RunAndReturn(run func(database.DB) database.DB) *VulndbCvesRepository_GetDB_Call

+ type VulndbCvesRepository_List_Call struct

+ func (_c *VulndbCvesRepository_List_Call) Return(_a0 []models.CVE, _a1 error) *VulndbCvesRepository_List_Call

+ func (_c *VulndbCvesRepository_List_Call) Run(run func(ids []string)) *VulndbCvesRepository_List_Call

+ func (_c *VulndbCvesRepository_List_Call) RunAndReturn(run func([]string) ([]models.CVE, error)) *VulndbCvesRepository_List_Call

+ type VulndbCvesRepository_Read_Call struct

+ func (_c *VulndbCvesRepository_Read_Call) Return(_a0 models.CVE, _a1 error) *VulndbCvesRepository_Read_Call

+ func (_c *VulndbCvesRepository_Read_Call) Run(run func(id string)) *VulndbCvesRepository_Read_Call

+ func (_c *VulndbCvesRepository_Read_Call) RunAndReturn(run func(string) (models.CVE, error)) *VulndbCvesRepository_Read_Call

+ type VulndbCvesRepository_SaveBatchCPEMatch_Call struct

+ func (_c *VulndbCvesRepository_SaveBatchCPEMatch_Call) Return(_a0 error) *VulndbCvesRepository_SaveBatchCPEMatch_Call

+ func (_c *VulndbCvesRepository_SaveBatchCPEMatch_Call) Run(run func(tx database.DB, matches []models.CPEMatch)) *VulndbCvesRepository_SaveBatchCPEMatch_Call

+ func (_c *VulndbCvesRepository_SaveBatchCPEMatch_Call) RunAndReturn(run func(database.DB, []models.CPEMatch) error) *VulndbCvesRepository_SaveBatchCPEMatch_Call

+ type VulndbCvesRepository_SaveBatch_Call struct

+ func (_c *VulndbCvesRepository_SaveBatch_Call) Return(_a0 error) *VulndbCvesRepository_SaveBatch_Call

+ func (_c *VulndbCvesRepository_SaveBatch_Call) Run(run func(tx database.DB, ts []models.CVE)) *VulndbCvesRepository_SaveBatch_Call

+ func (_c *VulndbCvesRepository_SaveBatch_Call) RunAndReturn(run func(database.DB, []models.CVE) error) *VulndbCvesRepository_SaveBatch_Call

+ type VulndbCvesRepository_SaveCveAffectedComponents_Call struct

+ func (_c *VulndbCvesRepository_SaveCveAffectedComponents_Call) Return(_a0 error) *VulndbCvesRepository_SaveCveAffectedComponents_Call

+ func (_c *VulndbCvesRepository_SaveCveAffectedComponents_Call) Run(run func(tx core.DB, cveId string, affectedComponentHashes []string)) *VulndbCvesRepository_SaveCveAffectedComponents_Call

+ func (_c *VulndbCvesRepository_SaveCveAffectedComponents_Call) RunAndReturn(run func(core.DB, string, []string) error) *VulndbCvesRepository_SaveCveAffectedComponents_Call

+ type VulndbCvesRepository_Save_Call struct

+ func (_c *VulndbCvesRepository_Save_Call) Return(_a0 error) *VulndbCvesRepository_Save_Call

+ func (_c *VulndbCvesRepository_Save_Call) Run(run func(tx database.DB, cve *models.CVE)) *VulndbCvesRepository_Save_Call

+ func (_c *VulndbCvesRepository_Save_Call) RunAndReturn(run func(database.DB, *models.CVE) error) *VulndbCvesRepository_Save_Call

+ type VulndbCvesRepository_Transaction_Call struct

+ func (_c *VulndbCvesRepository_Transaction_Call) Return(_a0 error) *VulndbCvesRepository_Transaction_Call

+ func (_c *VulndbCvesRepository_Transaction_Call) Run(run func(_a0 func(database.DB) error)) *VulndbCvesRepository_Transaction_Call

+ func (_c *VulndbCvesRepository_Transaction_Call) RunAndReturn(run func(func(database.DB) error) error) *VulndbCvesRepository_Transaction_Call

+ type VulndbCwesRepository struct

+ func NewVulndbCwesRepository(t interface{ ... }) *VulndbCwesRepository

+ func (_m *VulndbCwesRepository) EXPECT() *VulndbCwesRepository_Expecter

+ func (_m *VulndbCwesRepository) GetAllCWEsID() ([]string, error)

+ func (_m *VulndbCwesRepository) SaveBatch(tx database.DB, cwes []models.CWE) error

+ type VulndbCwesRepository_Expecter struct

+ func (_e *VulndbCwesRepository_Expecter) GetAllCWEsID() *VulndbCwesRepository_GetAllCWEsID_Call

+ func (_e *VulndbCwesRepository_Expecter) SaveBatch(tx interface{}, cwes interface{}) *VulndbCwesRepository_SaveBatch_Call

+ type VulndbCwesRepository_GetAllCWEsID_Call struct

+ func (_c *VulndbCwesRepository_GetAllCWEsID_Call) Return(_a0 []string, _a1 error) *VulndbCwesRepository_GetAllCWEsID_Call

+ func (_c *VulndbCwesRepository_GetAllCWEsID_Call) Run(run func()) *VulndbCwesRepository_GetAllCWEsID_Call

+ func (_c *VulndbCwesRepository_GetAllCWEsID_Call) RunAndReturn(run func() ([]string, error)) *VulndbCwesRepository_GetAllCWEsID_Call

+ type VulndbCwesRepository_SaveBatch_Call struct

+ func (_c *VulndbCwesRepository_SaveBatch_Call) Return(_a0 error) *VulndbCwesRepository_SaveBatch_Call

+ func (_c *VulndbCwesRepository_SaveBatch_Call) Run(run func(tx database.DB, cwes []models.CWE)) *VulndbCwesRepository_SaveBatch_Call

+ func (_c *VulndbCwesRepository_SaveBatch_Call) RunAndReturn(run func(database.DB, []models.CWE) error) *VulndbCwesRepository_SaveBatch_Call

+ type VulndbExploitsRepository struct

+ func NewVulndbExploitsRepository(t interface{ ... }) *VulndbExploitsRepository

+ func (_m *VulndbExploitsRepository) EXPECT() *VulndbExploitsRepository_Expecter

+ func (_m *VulndbExploitsRepository) GetAllExploitsID() ([]string, error)

+ func (_m *VulndbExploitsRepository) SaveBatch(tx core.DB, exploits []models.Exploit) error

+ type VulndbExploitsRepository_Expecter struct

+ func (_e *VulndbExploitsRepository_Expecter) GetAllExploitsID() *VulndbExploitsRepository_GetAllExploitsID_Call

+ func (_e *VulndbExploitsRepository_Expecter) SaveBatch(tx interface{}, exploits interface{}) *VulndbExploitsRepository_SaveBatch_Call

+ type VulndbExploitsRepository_GetAllExploitsID_Call struct

+ func (_c *VulndbExploitsRepository_GetAllExploitsID_Call) Return(_a0 []string, _a1 error) *VulndbExploitsRepository_GetAllExploitsID_Call

+ func (_c *VulndbExploitsRepository_GetAllExploitsID_Call) Run(run func()) *VulndbExploitsRepository_GetAllExploitsID_Call

+ func (_c *VulndbExploitsRepository_GetAllExploitsID_Call) RunAndReturn(run func() ([]string, error)) *VulndbExploitsRepository_GetAllExploitsID_Call

+ type VulndbExploitsRepository_SaveBatch_Call struct

+ func (_c *VulndbExploitsRepository_SaveBatch_Call) Return(_a0 error) *VulndbExploitsRepository_SaveBatch_Call

+ func (_c *VulndbExploitsRepository_SaveBatch_Call) Run(run func(tx core.DB, exploits []models.Exploit)) *VulndbExploitsRepository_SaveBatch_Call

+ func (_c *VulndbExploitsRepository_SaveBatch_Call) RunAndReturn(run func(core.DB, []models.Exploit) error) *VulndbExploitsRepository_SaveBatch_Call

type VulndbLeaderElector

+ func (_m *VulndbLeaderElector) IfLeader(ctx context.Context, fn func() error)

type VulndbLeaderElector_Expecter

+ func (_e *VulndbLeaderElector_Expecter) IfLeader(ctx interface{}, fn interface{}) *VulndbLeaderElector_IfLeader_Call

+ type VulndbLeaderElector_IfLeader_Call struct

+ func (_c *VulndbLeaderElector_IfLeader_Call) Return() *VulndbLeaderElector_IfLeader_Call

+ func (_c *VulndbLeaderElector_IfLeader_Call) Run(run func(ctx context.Context, fn func() error)) *VulndbLeaderElector_IfLeader_Call

+ func (_c *VulndbLeaderElector_IfLeader_Call) RunAndReturn(run func(context.Context, func() error)) *VulndbLeaderElector_IfLeader_Call

v0.5.3

Aug 8, 2024

v0.5.2

Aug 8, 2024

v0.5.1

Aug 7, 2024

Changes in this version

type AssetAssetService

+ func (_m *AssetAssetService) BuildSBOM(_a0 models.Asset, version string, orgName string, ...) *cyclonedx.BOM

+ type AssetAssetService_BuildSBOM_Call struct

+ func (_c *AssetAssetService_BuildSBOM_Call) Return(_a0 *cyclonedx.BOM) *AssetAssetService_BuildSBOM_Call

+ func (_c *AssetAssetService_BuildSBOM_Call) Run(run func(_a0 models.Asset, version string, orgName string, ...)) *AssetAssetService_BuildSBOM_Call

+ func (_c *AssetAssetService_BuildSBOM_Call) RunAndReturn(...) *AssetAssetService_BuildSBOM_Call

type AssetAssetService_Expecter

+ func (_e *AssetAssetService_Expecter) BuildSBOM(_a0 interface{}, version interface{}, orgName interface{}, ...) *AssetAssetService_BuildSBOM_Call

type AssetFlawRepository

+ func (_m *AssetFlawRepository) GetFlawsByPurl(tx *gorm.DB, purl []string) ([]models.Flaw, error)

type AssetFlawRepository_Expecter

+ func (_e *AssetFlawRepository_Expecter) GetFlawsByPurl(tx interface{}, purl interface{}) *AssetFlawRepository_GetFlawsByPurl_Call

+ type AssetFlawRepository_GetFlawsByPurl_Call struct

+ func (_c *AssetFlawRepository_GetFlawsByPurl_Call) Return(_a0 []models.Flaw, _a1 error) *AssetFlawRepository_GetFlawsByPurl_Call

+ func (_c *AssetFlawRepository_GetFlawsByPurl_Call) Run(run func(tx *gorm.DB, purl []string)) *AssetFlawRepository_GetFlawsByPurl_Call

+ func (_c *AssetFlawRepository_GetFlawsByPurl_Call) RunAndReturn(run func(*gorm.DB, []string) ([]models.Flaw, error)) *AssetFlawRepository_GetFlawsByPurl_Call

+ type CoreThirdPartyIntegration struct

+ func NewCoreThirdPartyIntegration(t interface{ ... }) *CoreThirdPartyIntegration

+ func (_m *CoreThirdPartyIntegration) EXPECT() *CoreThirdPartyIntegration_Expecter

+ func (_m *CoreThirdPartyIntegration) FinishInstallation(ctx echo.Context) error

+ func (_m *CoreThirdPartyIntegration) HandleEvent(event interface{}) error

+ func (_m *CoreThirdPartyIntegration) HandleWebhook(ctx echo.Context) error

+ func (_m *CoreThirdPartyIntegration) IntegrationEnabled(ctx echo.Context) bool

+ func (_m *CoreThirdPartyIntegration) ListRepositories(ctx echo.Context) ([]core.Repository, error)

+ func (_m *CoreThirdPartyIntegration) WantsToFinishInstallation(ctx echo.Context) bool

+ func (_m *CoreThirdPartyIntegration) WantsToHandleWebhook(ctx echo.Context) bool

+ type CoreThirdPartyIntegration_Expecter struct

+ func (_e *CoreThirdPartyIntegration_Expecter) FinishInstallation(ctx interface{}) *CoreThirdPartyIntegration_FinishInstallation_Call

+ func (_e *CoreThirdPartyIntegration_Expecter) HandleEvent(event interface{}) *CoreThirdPartyIntegration_HandleEvent_Call

+ func (_e *CoreThirdPartyIntegration_Expecter) HandleWebhook(ctx interface{}) *CoreThirdPartyIntegration_HandleWebhook_Call

+ func (_e *CoreThirdPartyIntegration_Expecter) IntegrationEnabled(ctx interface{}) *CoreThirdPartyIntegration_IntegrationEnabled_Call

+ func (_e *CoreThirdPartyIntegration_Expecter) ListRepositories(ctx interface{}) *CoreThirdPartyIntegration_ListRepositories_Call

+ func (_e *CoreThirdPartyIntegration_Expecter) WantsToFinishInstallation(ctx interface{}) *CoreThirdPartyIntegration_WantsToFinishInstallation_Call

+ func (_e *CoreThirdPartyIntegration_Expecter) WantsToHandleWebhook(ctx interface{}) *CoreThirdPartyIntegration_WantsToHandleWebhook_Call

+ type CoreThirdPartyIntegration_FinishInstallation_Call struct

+ func (_c *CoreThirdPartyIntegration_FinishInstallation_Call) Return(_a0 error) *CoreThirdPartyIntegration_FinishInstallation_Call

+ func (_c *CoreThirdPartyIntegration_FinishInstallation_Call) Run(run func(ctx echo.Context)) *CoreThirdPartyIntegration_FinishInstallation_Call

+ func (_c *CoreThirdPartyIntegration_FinishInstallation_Call) RunAndReturn(run func(echo.Context) error) *CoreThirdPartyIntegration_FinishInstallation_Call

+ type CoreThirdPartyIntegration_HandleEvent_Call struct

+ func (_c *CoreThirdPartyIntegration_HandleEvent_Call) Return(_a0 error) *CoreThirdPartyIntegration_HandleEvent_Call

+ func (_c *CoreThirdPartyIntegration_HandleEvent_Call) Run(run func(event interface{})) *CoreThirdPartyIntegration_HandleEvent_Call

+ func (_c *CoreThirdPartyIntegration_HandleEvent_Call) RunAndReturn(run func(interface{}) error) *CoreThirdPartyIntegration_HandleEvent_Call

+ type CoreThirdPartyIntegration_HandleWebhook_Call struct

+ func (_c *CoreThirdPartyIntegration_HandleWebhook_Call) Return(_a0 error) *CoreThirdPartyIntegration_HandleWebhook_Call

+ func (_c *CoreThirdPartyIntegration_HandleWebhook_Call) Run(run func(ctx echo.Context)) *CoreThirdPartyIntegration_HandleWebhook_Call

+ func (_c *CoreThirdPartyIntegration_HandleWebhook_Call) RunAndReturn(run func(echo.Context) error) *CoreThirdPartyIntegration_HandleWebhook_Call

+ type CoreThirdPartyIntegration_IntegrationEnabled_Call struct

+ func (_c *CoreThirdPartyIntegration_IntegrationEnabled_Call) Return(_a0 bool) *CoreThirdPartyIntegration_IntegrationEnabled_Call

+ func (_c *CoreThirdPartyIntegration_IntegrationEnabled_Call) Run(run func(ctx echo.Context)) *CoreThirdPartyIntegration_IntegrationEnabled_Call

+ func (_c *CoreThirdPartyIntegration_IntegrationEnabled_Call) RunAndReturn(run func(echo.Context) bool) *CoreThirdPartyIntegration_IntegrationEnabled_Call

+ type CoreThirdPartyIntegration_ListRepositories_Call struct

+ func (_c *CoreThirdPartyIntegration_ListRepositories_Call) Return(_a0 []core.Repository, _a1 error) *CoreThirdPartyIntegration_ListRepositories_Call

+ func (_c *CoreThirdPartyIntegration_ListRepositories_Call) Run(run func(ctx echo.Context)) *CoreThirdPartyIntegration_ListRepositories_Call

+ func (_c *CoreThirdPartyIntegration_ListRepositories_Call) RunAndReturn(run func(echo.Context) ([]core.Repository, error)) *CoreThirdPartyIntegration_ListRepositories_Call

+ type CoreThirdPartyIntegration_WantsToFinishInstallation_Call struct

+ func (_c *CoreThirdPartyIntegration_WantsToFinishInstallation_Call) Return(_a0 bool) *CoreThirdPartyIntegration_WantsToFinishInstallation_Call

+ func (_c *CoreThirdPartyIntegration_WantsToFinishInstallation_Call) Run(run func(ctx echo.Context)) *CoreThirdPartyIntegration_WantsToFinishInstallation_Call

+ func (_c *CoreThirdPartyIntegration_WantsToFinishInstallation_Call) RunAndReturn(run func(echo.Context) bool) *CoreThirdPartyIntegration_WantsToFinishInstallation_Call

+ type CoreThirdPartyIntegration_WantsToHandleWebhook_Call struct

+ func (_c *CoreThirdPartyIntegration_WantsToHandleWebhook_Call) Return(_a0 bool) *CoreThirdPartyIntegration_WantsToHandleWebhook_Call

+ func (_c *CoreThirdPartyIntegration_WantsToHandleWebhook_Call) Run(run func(ctx echo.Context)) *CoreThirdPartyIntegration_WantsToHandleWebhook_Call

+ func (_c *CoreThirdPartyIntegration_WantsToHandleWebhook_Call) RunAndReturn(run func(echo.Context) bool) *CoreThirdPartyIntegration_WantsToHandleWebhook_Call

type IntegrationsGithubAppInstallationRepository

+ func (_m *IntegrationsGithubAppInstallationRepository) Delete(tx *gorm.DB, installationID int) error

+ type IntegrationsGithubAppInstallationRepository_Delete_Call struct

+ func (_c *IntegrationsGithubAppInstallationRepository_Delete_Call) Return(_a0 error) *IntegrationsGithubAppInstallationRepository_Delete_Call

+ func (_c *IntegrationsGithubAppInstallationRepository_Delete_Call) Run(run func(tx *gorm.DB, installationID int)) *IntegrationsGithubAppInstallationRepository_Delete_Call

+ func (_c *IntegrationsGithubAppInstallationRepository_Delete_Call) RunAndReturn(run func(*gorm.DB, int) error) *IntegrationsGithubAppInstallationRepository_Delete_Call

type IntegrationsGithubAppInstallationRepository_Expecter

+ func (_e *IntegrationsGithubAppInstallationRepository_Expecter) Delete(tx interface{}, installationID interface{}) *IntegrationsGithubAppInstallationRepository_Delete_Call

+ type NormalizeSBOM struct

+ func NewNormalizeSBOM(t interface{ ... }) *NormalizeSBOM

+ func (_m *NormalizeSBOM) EXPECT() *NormalizeSBOM_Expecter

+ func (_m *NormalizeSBOM) GetComponents() *[]cyclonedx.Component

+ func (_m *NormalizeSBOM) GetDependencies() *[]cyclonedx.Dependency

+ func (_m *NormalizeSBOM) GetMetadata() *cyclonedx.Metadata

+ type NormalizeSBOM_Expecter struct

+ func (_e *NormalizeSBOM_Expecter) GetComponents() *NormalizeSBOM_GetComponents_Call

+ func (_e *NormalizeSBOM_Expecter) GetDependencies() *NormalizeSBOM_GetDependencies_Call

+ func (_e *NormalizeSBOM_Expecter) GetMetadata() *NormalizeSBOM_GetMetadata_Call

+ type NormalizeSBOM_GetComponents_Call struct

+ func (_c *NormalizeSBOM_GetComponents_Call) Return(_a0 *[]cyclonedx.Component) *NormalizeSBOM_GetComponents_Call

+ func (_c *NormalizeSBOM_GetComponents_Call) Run(run func()) *NormalizeSBOM_GetComponents_Call

+ func (_c *NormalizeSBOM_GetComponents_Call) RunAndReturn(run func() *[]cyclonedx.Component) *NormalizeSBOM_GetComponents_Call

+ type NormalizeSBOM_GetDependencies_Call struct

+ func (_c *NormalizeSBOM_GetDependencies_Call) Return(_a0 *[]cyclonedx.Dependency) *NormalizeSBOM_GetDependencies_Call

+ func (_c *NormalizeSBOM_GetDependencies_Call) Run(run func()) *NormalizeSBOM_GetDependencies_Call

+ func (_c *NormalizeSBOM_GetDependencies_Call) RunAndReturn(run func() *[]cyclonedx.Dependency) *NormalizeSBOM_GetDependencies_Call

+ type NormalizeSBOM_GetMetadata_Call struct

+ func (_c *NormalizeSBOM_GetMetadata_Call) Return(_a0 *cyclonedx.Metadata) *NormalizeSBOM_GetMetadata_Call

+ func (_c *NormalizeSBOM_GetMetadata_Call) Run(run func()) *NormalizeSBOM_GetMetadata_Call

+ func (_c *NormalizeSBOM_GetMetadata_Call) RunAndReturn(run func() *cyclonedx.Metadata) *NormalizeSBOM_GetMetadata_Call

type ProjectProjectRepository

+ func (_m *ProjectProjectRepository) Update(tx *gorm.DB, _a1 *models.Project) error

type ProjectProjectRepository_Expecter

+ func (_e *ProjectProjectRepository_Expecter) Update(tx interface{}, _a1 interface{}) *ProjectProjectRepository_Update_Call

+ type ProjectProjectRepository_Update_Call struct

+ func (_c *ProjectProjectRepository_Update_Call) Return(_a0 error) *ProjectProjectRepository_Update_Call

+ func (_c *ProjectProjectRepository_Update_Call) Run(run func(tx *gorm.DB, _a1 *models.Project)) *ProjectProjectRepository_Update_Call

+ func (_c *ProjectProjectRepository_Update_Call) RunAndReturn(run func(*gorm.DB, *models.Project) error) *ProjectProjectRepository_Update_Call

type ScanComponentRepository

+ func (_m *ScanComponentRepository) LoadAssetComponents(tx *gorm.DB, asset models.Asset, scanType string, version string) ([]models.ComponentDependency, error)

type ScanComponentRepository_Expecter

+ func (_e *ScanComponentRepository_Expecter) LoadAssetComponents(tx interface{}, asset interface{}, scanType interface{}, version interface{}) *ScanComponentRepository_LoadAssetComponents_Call

+ type ScanComponentRepository_LoadAssetComponents_Call struct

+ func (_c *ScanComponentRepository_LoadAssetComponents_Call) Return(_a0 []models.ComponentDependency, _a1 error) *ScanComponentRepository_LoadAssetComponents_Call

+ func (_c *ScanComponentRepository_LoadAssetComponents_Call) Run(run func(tx *gorm.DB, asset models.Asset, scanType string, version string)) *ScanComponentRepository_LoadAssetComponents_Call

+ func (_c *ScanComponentRepository_LoadAssetComponents_Call) RunAndReturn(...) *ScanComponentRepository_LoadAssetComponents_Call

type VulndbCveRepository

+ func (_m *VulndbCveRepository) SaveBatchCPEMatch(tx *gorm.DB, matches []models.CPEMatch) error

type VulndbCveRepository_Expecter

+ func (_e *VulndbCveRepository_Expecter) SaveBatchCPEMatch(tx interface{}, matches interface{}) *VulndbCveRepository_SaveBatchCPEMatch_Call

+ type VulndbCveRepository_SaveBatchCPEMatch_Call struct

+ func (_c *VulndbCveRepository_SaveBatchCPEMatch_Call) Return(_a0 error) *VulndbCveRepository_SaveBatchCPEMatch_Call

+ func (_c *VulndbCveRepository_SaveBatchCPEMatch_Call) Run(run func(tx *gorm.DB, matches []models.CPEMatch)) *VulndbCveRepository_SaveBatchCPEMatch_Call

+ func (_c *VulndbCveRepository_SaveBatchCPEMatch_Call) RunAndReturn(run func(*gorm.DB, []models.CPEMatch) error) *VulndbCveRepository_SaveBatchCPEMatch_Call

v0.5.0

Jul 17, 2024

v0.4.19

Jul 17, 2024

v0.4.18

Jul 8, 2024

v0.4.17

Jul 7, 2024

Changes in this version

+ type AssetAssetComponentsLoader struct

+ func NewAssetAssetComponentsLoader(t interface{ ... }) *AssetAssetComponentsLoader

+ func (_m *AssetAssetComponentsLoader) EXPECT() *AssetAssetComponentsLoader_Expecter

+ func (_m *AssetAssetComponentsLoader) GetVersions(tx *gorm.DB, _a1 models.Asset) ([]string, error)

+ func (_m *AssetAssetComponentsLoader) LoadAssetComponents(tx *gorm.DB, _a1 models.Asset, version string) ([]models.ComponentDependency, error)

+ type AssetAssetComponentsLoader_Expecter struct

+ func (_e *AssetAssetComponentsLoader_Expecter) GetVersions(tx interface{}, _a1 interface{}) *AssetAssetComponentsLoader_GetVersions_Call

+ func (_e *AssetAssetComponentsLoader_Expecter) LoadAssetComponents(tx interface{}, _a1 interface{}, version interface{}) *AssetAssetComponentsLoader_LoadAssetComponents_Call

+ type AssetAssetComponentsLoader_GetVersions_Call struct

+ func (_c *AssetAssetComponentsLoader_GetVersions_Call) Return(_a0 []string, _a1 error) *AssetAssetComponentsLoader_GetVersions_Call

+ func (_c *AssetAssetComponentsLoader_GetVersions_Call) Run(run func(tx *gorm.DB, _a1 models.Asset)) *AssetAssetComponentsLoader_GetVersions_Call

+ func (_c *AssetAssetComponentsLoader_GetVersions_Call) RunAndReturn(run func(*gorm.DB, models.Asset) ([]string, error)) *AssetAssetComponentsLoader_GetVersions_Call

+ type AssetAssetComponentsLoader_LoadAssetComponents_Call struct

+ func (_c *AssetAssetComponentsLoader_LoadAssetComponents_Call) Return(_a0 []models.ComponentDependency, _a1 error) *AssetAssetComponentsLoader_LoadAssetComponents_Call

+ func (_c *AssetAssetComponentsLoader_LoadAssetComponents_Call) Run(run func(tx *gorm.DB, _a1 models.Asset, version string)) *AssetAssetComponentsLoader_LoadAssetComponents_Call

+ func (_c *AssetAssetComponentsLoader_LoadAssetComponents_Call) RunAndReturn(run func(*gorm.DB, models.Asset, string) ([]models.ComponentDependency, error)) *AssetAssetComponentsLoader_LoadAssetComponents_Call

+ type AssetAssetRepository struct

+ func NewAssetAssetRepository(t interface{ ... }) *AssetAssetRepository

+ func (_m *AssetAssetRepository) EXPECT() *AssetAssetRepository_Expecter

+ func (_m *AssetAssetRepository) Save(tx *gorm.DB, _a1 *models.Asset) error

+ type AssetAssetRepository_Expecter struct

+ func (_e *AssetAssetRepository_Expecter) Save(tx interface{}, _a1 interface{}) *AssetAssetRepository_Save_Call

+ type AssetAssetRepository_Save_Call struct

+ func (_c *AssetAssetRepository_Save_Call) Return(_a0 error) *AssetAssetRepository_Save_Call

+ func (_c *AssetAssetRepository_Save_Call) Run(run func(tx *gorm.DB, _a1 *models.Asset)) *AssetAssetRepository_Save_Call

+ func (_c *AssetAssetRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.Asset) error) *AssetAssetRepository_Save_Call

+ type AssetAssetService struct

+ func NewAssetAssetService(t interface{ ... }) *AssetAssetService

+ func (_m *AssetAssetService) EXPECT() *AssetAssetService_Expecter

+ func (_m *AssetAssetService) UpdateAssetRequirements(_a0 models.Asset, responsible string, justification string) error

+ type AssetAssetService_Expecter struct

+ func (_e *AssetAssetService_Expecter) UpdateAssetRequirements(_a0 interface{}, responsible interface{}, justification interface{}) *AssetAssetService_UpdateAssetRequirements_Call

+ type AssetAssetService_UpdateAssetRequirements_Call struct

+ func (_c *AssetAssetService_UpdateAssetRequirements_Call) Return(_a0 error) *AssetAssetService_UpdateAssetRequirements_Call

+ func (_c *AssetAssetService_UpdateAssetRequirements_Call) Run(run func(_a0 models.Asset, responsible string, justification string)) *AssetAssetService_UpdateAssetRequirements_Call

+ func (_c *AssetAssetService_UpdateAssetRequirements_Call) RunAndReturn(run func(models.Asset, string, string) error) *AssetAssetService_UpdateAssetRequirements_Call

+ type AssetComponentRepository struct

+ func NewAssetComponentRepository(t interface{ ... }) *AssetComponentRepository

+ func (_m *AssetComponentRepository) EXPECT() *AssetComponentRepository_Expecter

+ func (_m *AssetComponentRepository) FindByPurl(tx *gorm.DB, purl string) (models.Component, error)

+ func (_m *AssetComponentRepository) HandleStateDiff(tx *gorm.DB, assetID uuid.UUID, version string, ...) error

+ func (_m *AssetComponentRepository) LoadAssetComponents(tx *gorm.DB, _a1 models.Asset, version string) ([]models.ComponentDependency, error)

+ func (_m *AssetComponentRepository) SaveBatch(tx *gorm.DB, components []models.Component) error

+ type AssetComponentRepository_Expecter struct

+ func (_e *AssetComponentRepository_Expecter) FindByPurl(tx interface{}, purl interface{}) *AssetComponentRepository_FindByPurl_Call

+ func (_e *AssetComponentRepository_Expecter) HandleStateDiff(tx interface{}, assetID interface{}, version interface{}, oldState interface{}, ...) *AssetComponentRepository_HandleStateDiff_Call

+ func (_e *AssetComponentRepository_Expecter) LoadAssetComponents(tx interface{}, _a1 interface{}, version interface{}) *AssetComponentRepository_LoadAssetComponents_Call

+ func (_e *AssetComponentRepository_Expecter) SaveBatch(tx interface{}, components interface{}) *AssetComponentRepository_SaveBatch_Call

+ type AssetComponentRepository_FindByPurl_Call struct

+ func (_c *AssetComponentRepository_FindByPurl_Call) Return(_a0 models.Component, _a1 error) *AssetComponentRepository_FindByPurl_Call

+ func (_c *AssetComponentRepository_FindByPurl_Call) Run(run func(tx *gorm.DB, purl string)) *AssetComponentRepository_FindByPurl_Call

+ func (_c *AssetComponentRepository_FindByPurl_Call) RunAndReturn(run func(*gorm.DB, string) (models.Component, error)) *AssetComponentRepository_FindByPurl_Call

+ type AssetComponentRepository_HandleStateDiff_Call struct

+ func (_c *AssetComponentRepository_HandleStateDiff_Call) Return(_a0 error) *AssetComponentRepository_HandleStateDiff_Call

+ func (_c *AssetComponentRepository_HandleStateDiff_Call) Run(run func(tx *gorm.DB, assetID uuid.UUID, version string, ...)) *AssetComponentRepository_HandleStateDiff_Call

+ func (_c *AssetComponentRepository_HandleStateDiff_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID, string, []models.ComponentDependency, ...) error) *AssetComponentRepository_HandleStateDiff_Call

+ type AssetComponentRepository_LoadAssetComponents_Call struct

+ func (_c *AssetComponentRepository_LoadAssetComponents_Call) Return(_a0 []models.ComponentDependency, _a1 error) *AssetComponentRepository_LoadAssetComponents_Call

+ func (_c *AssetComponentRepository_LoadAssetComponents_Call) Run(run func(tx *gorm.DB, _a1 models.Asset, version string)) *AssetComponentRepository_LoadAssetComponents_Call

+ func (_c *AssetComponentRepository_LoadAssetComponents_Call) RunAndReturn(run func(*gorm.DB, models.Asset, string) ([]models.ComponentDependency, error)) *AssetComponentRepository_LoadAssetComponents_Call

+ type AssetComponentRepository_SaveBatch_Call struct

+ func (_c *AssetComponentRepository_SaveBatch_Call) Return(_a0 error) *AssetComponentRepository_SaveBatch_Call

+ func (_c *AssetComponentRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, components []models.Component)) *AssetComponentRepository_SaveBatch_Call

+ func (_c *AssetComponentRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Component) error) *AssetComponentRepository_SaveBatch_Call

+ type AssetFlawRepository struct

+ func NewAssetFlawRepository(t interface{ ... }) *AssetFlawRepository

+ func (_m *AssetFlawRepository) EXPECT() *AssetFlawRepository_Expecter

+ func (_m *AssetFlawRepository) GetAllFlawsByAssetID(tx *gorm.DB, assetID uuid.UUID) ([]models.Flaw, error)

+ func (_m *AssetFlawRepository) ListByScanner(assetID uuid.UUID, scannerID string) ([]models.Flaw, error)

+ func (_m *AssetFlawRepository) SaveBatch(db *gorm.DB, flaws []models.Flaw) error

+ func (_m *AssetFlawRepository) Transaction(txFunc func(*gorm.DB) error) error

+ type AssetFlawRepository_Expecter struct

+ func (_e *AssetFlawRepository_Expecter) GetAllFlawsByAssetID(tx interface{}, assetID interface{}) *AssetFlawRepository_GetAllFlawsByAssetID_Call

+ func (_e *AssetFlawRepository_Expecter) ListByScanner(assetID interface{}, scannerID interface{}) *AssetFlawRepository_ListByScanner_Call

+ func (_e *AssetFlawRepository_Expecter) SaveBatch(db interface{}, flaws interface{}) *AssetFlawRepository_SaveBatch_Call

+ func (_e *AssetFlawRepository_Expecter) Transaction(txFunc interface{}) *AssetFlawRepository_Transaction_Call

+ type AssetFlawRepository_GetAllFlawsByAssetID_Call struct

+ func (_c *AssetFlawRepository_GetAllFlawsByAssetID_Call) Return(_a0 []models.Flaw, _a1 error) *AssetFlawRepository_GetAllFlawsByAssetID_Call

+ func (_c *AssetFlawRepository_GetAllFlawsByAssetID_Call) Run(run func(tx *gorm.DB, assetID uuid.UUID)) *AssetFlawRepository_GetAllFlawsByAssetID_Call

+ func (_c *AssetFlawRepository_GetAllFlawsByAssetID_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) ([]models.Flaw, error)) *AssetFlawRepository_GetAllFlawsByAssetID_Call

+ type AssetFlawRepository_ListByScanner_Call struct

+ func (_c *AssetFlawRepository_ListByScanner_Call) Return(_a0 []models.Flaw, _a1 error) *AssetFlawRepository_ListByScanner_Call

+ func (_c *AssetFlawRepository_ListByScanner_Call) Run(run func(assetID uuid.UUID, scannerID string)) *AssetFlawRepository_ListByScanner_Call

+ func (_c *AssetFlawRepository_ListByScanner_Call) RunAndReturn(run func(uuid.UUID, string) ([]models.Flaw, error)) *AssetFlawRepository_ListByScanner_Call

+ type AssetFlawRepository_SaveBatch_Call struct

+ func (_c *AssetFlawRepository_SaveBatch_Call) Return(_a0 error) *AssetFlawRepository_SaveBatch_Call

+ func (_c *AssetFlawRepository_SaveBatch_Call) Run(run func(db *gorm.DB, flaws []models.Flaw)) *AssetFlawRepository_SaveBatch_Call

+ func (_c *AssetFlawRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Flaw) error) *AssetFlawRepository_SaveBatch_Call

+ type AssetFlawRepository_Transaction_Call struct

+ func (_c *AssetFlawRepository_Transaction_Call) Return(_a0 error) *AssetFlawRepository_Transaction_Call

+ func (_c *AssetFlawRepository_Transaction_Call) Run(run func(txFunc func(*gorm.DB) error)) *AssetFlawRepository_Transaction_Call

+ func (_c *AssetFlawRepository_Transaction_Call) RunAndReturn(run func(func(*gorm.DB) error) error) *AssetFlawRepository_Transaction_Call

+ type AssetFlawService struct

+ func NewAssetFlawService(t interface{ ... }) *AssetFlawService

+ func (_m *AssetFlawService) EXPECT() *AssetFlawService_Expecter

+ func (_m *AssetFlawService) RecalculateRawRiskAssessment(tx *gorm.DB, userID string, flaws []models.Flaw, justification string, ...) error

+ func (_m *AssetFlawService) UpdateFlawState(tx *gorm.DB, userID string, flaw *models.Flaw, statusType string, ...) error

+ func (_m *AssetFlawService) UserDetectedFlaws(tx *gorm.DB, userID string, flaws []models.Flaw, _a3 models.Asset) error

+ func (_m *AssetFlawService) UserFixedFlaws(tx *gorm.DB, userID string, flaws []models.Flaw) error

+ type AssetFlawService_Expecter struct

+ func (_e *AssetFlawService_Expecter) RecalculateRawRiskAssessment(tx interface{}, userID interface{}, flaws interface{}, ...) *AssetFlawService_RecalculateRawRiskAssessment_Call

+ func (_e *AssetFlawService_Expecter) UpdateFlawState(tx interface{}, userID interface{}, flaw interface{}, statusType interface{}, ...) *AssetFlawService_UpdateFlawState_Call

+ func (_e *AssetFlawService_Expecter) UserDetectedFlaws(tx interface{}, userID interface{}, flaws interface{}, _a3 interface{}) *AssetFlawService_UserDetectedFlaws_Call

+ func (_e *AssetFlawService_Expecter) UserFixedFlaws(tx interface{}, userID interface{}, flaws interface{}) *AssetFlawService_UserFixedFlaws_Call

+ type AssetFlawService_RecalculateRawRiskAssessment_Call struct

+ func (_c *AssetFlawService_RecalculateRawRiskAssessment_Call) Return(_a0 error) *AssetFlawService_RecalculateRawRiskAssessment_Call

+ func (_c *AssetFlawService_RecalculateRawRiskAssessment_Call) Run(...) *AssetFlawService_RecalculateRawRiskAssessment_Call

+ func (_c *AssetFlawService_RecalculateRawRiskAssessment_Call) RunAndReturn(run func(*gorm.DB, string, []models.Flaw, string, models.Asset) error) *AssetFlawService_RecalculateRawRiskAssessment_Call

+ type AssetFlawService_UpdateFlawState_Call struct

+ func (_c *AssetFlawService_UpdateFlawState_Call) Return(_a0 error) *AssetFlawService_UpdateFlawState_Call

+ func (_c *AssetFlawService_UpdateFlawState_Call) Run(...) *AssetFlawService_UpdateFlawState_Call

+ func (_c *AssetFlawService_UpdateFlawState_Call) RunAndReturn(run func(*gorm.DB, string, *models.Flaw, string, *string) error) *AssetFlawService_UpdateFlawState_Call

+ type AssetFlawService_UserDetectedFlaws_Call struct

+ func (_c *AssetFlawService_UserDetectedFlaws_Call) Return(_a0 error) *AssetFlawService_UserDetectedFlaws_Call

+ func (_c *AssetFlawService_UserDetectedFlaws_Call) Run(run func(tx *gorm.DB, userID string, flaws []models.Flaw, _a3 models.Asset)) *AssetFlawService_UserDetectedFlaws_Call

+ func (_c *AssetFlawService_UserDetectedFlaws_Call) RunAndReturn(run func(*gorm.DB, string, []models.Flaw, models.Asset) error) *AssetFlawService_UserDetectedFlaws_Call

+ type AssetFlawService_UserFixedFlaws_Call struct

+ func (_c *AssetFlawService_UserFixedFlaws_Call) Return(_a0 error) *AssetFlawService_UserFixedFlaws_Call

+ func (_c *AssetFlawService_UserFixedFlaws_Call) Run(run func(tx *gorm.DB, userID string, flaws []models.Flaw)) *AssetFlawService_UserFixedFlaws_Call

+ func (_c *AssetFlawService_UserFixedFlaws_Call) RunAndReturn(run func(*gorm.DB, string, []models.Flaw) error) *AssetFlawService_UserFixedFlaws_Call

+ type AssetRepository struct

+ func NewAssetRepository(t interface{ ... }) *AssetRepository

+ func (_m *AssetRepository) Begin() *gorm.DB

+ func (_m *AssetRepository) Create(tx *gorm.DB, t *models.Asset) error

+ func (_m *AssetRepository) CreateBatch(tx *gorm.DB, ts []models.Asset) error

+ func (_m *AssetRepository) Delete(tx *gorm.DB, id uuid.UUID) error

+ func (_m *AssetRepository) EXPECT() *AssetRepository_Expecter

+ func (_m *AssetRepository) FindByName(name string) (models.Asset, error)

+ func (_m *AssetRepository) FindOrCreate(tx *gorm.DB, name string) (models.Asset, error)

+ func (_m *AssetRepository) GetAssetIDBySlug(projectID uuid.UUID, slug string) (uuid.UUID, error)

+ func (_m *AssetRepository) GetByProjectID(projectID uuid.UUID) ([]models.Asset, error)

+ func (_m *AssetRepository) GetDB(tx *gorm.DB) *gorm.DB

+ func (_m *AssetRepository) List(ids []uuid.UUID) ([]models.Asset, error)

+ func (_m *AssetRepository) Read(id uuid.UUID) (models.Asset, error)

+ func (_m *AssetRepository) ReadBySlug(projectID uuid.UUID, slug string) (models.Asset, error)

+ func (_m *AssetRepository) Save(tx *gorm.DB, t *models.Asset) error

+ func (_m *AssetRepository) SaveBatch(tx *gorm.DB, ts []models.Asset) error

+ func (_m *AssetRepository) Transaction(_a0 func(*gorm.DB) error) error

+ func (_m *AssetRepository) Update(tx *gorm.DB, _a1 *models.Asset) error

+ type AssetRepository_Begin_Call struct

+ func (_c *AssetRepository_Begin_Call) Return(_a0 *gorm.DB) *AssetRepository_Begin_Call

+ func (_c *AssetRepository_Begin_Call) Run(run func()) *AssetRepository_Begin_Call

+ func (_c *AssetRepository_Begin_Call) RunAndReturn(run func() *gorm.DB) *AssetRepository_Begin_Call

+ type AssetRepository_CreateBatch_Call struct

+ func (_c *AssetRepository_CreateBatch_Call) Return(_a0 error) *AssetRepository_CreateBatch_Call

+ func (_c *AssetRepository_CreateBatch_Call) Run(run func(tx *gorm.DB, ts []models.Asset)) *AssetRepository_CreateBatch_Call

+ func (_c *AssetRepository_CreateBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Asset) error) *AssetRepository_CreateBatch_Call

+ type AssetRepository_Create_Call struct

+ func (_c *AssetRepository_Create_Call) Return(_a0 error) *AssetRepository_Create_Call

+ func (_c *AssetRepository_Create_Call) Run(run func(tx *gorm.DB, t *models.Asset)) *AssetRepository_Create_Call

+ func (_c *AssetRepository_Create_Call) RunAndReturn(run func(*gorm.DB, *models.Asset) error) *AssetRepository_Create_Call

+ type AssetRepository_Delete_Call struct

+ func (_c *AssetRepository_Delete_Call) Return(_a0 error) *AssetRepository_Delete_Call

+ func (_c *AssetRepository_Delete_Call) Run(run func(tx *gorm.DB, id uuid.UUID)) *AssetRepository_Delete_Call

+ func (_c *AssetRepository_Delete_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *AssetRepository_Delete_Call

+ type AssetRepository_Expecter struct

+ func (_e *AssetRepository_Expecter) Begin() *AssetRepository_Begin_Call

+ func (_e *AssetRepository_Expecter) Create(tx interface{}, t interface{}) *AssetRepository_Create_Call

+ func (_e *AssetRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *AssetRepository_CreateBatch_Call

+ func (_e *AssetRepository_Expecter) Delete(tx interface{}, id interface{}) *AssetRepository_Delete_Call

+ func (_e *AssetRepository_Expecter) FindByName(name interface{}) *AssetRepository_FindByName_Call

+ func (_e *AssetRepository_Expecter) FindOrCreate(tx interface{}, name interface{}) *AssetRepository_FindOrCreate_Call

+ func (_e *AssetRepository_Expecter) GetAssetIDBySlug(projectID interface{}, slug interface{}) *AssetRepository_GetAssetIDBySlug_Call

+ func (_e *AssetRepository_Expecter) GetByProjectID(projectID interface{}) *AssetRepository_GetByProjectID_Call

+ func (_e *AssetRepository_Expecter) GetDB(tx interface{}) *AssetRepository_GetDB_Call

+ func (_e *AssetRepository_Expecter) List(ids interface{}) *AssetRepository_List_Call

+ func (_e *AssetRepository_Expecter) Read(id interface{}) *AssetRepository_Read_Call

+ func (_e *AssetRepository_Expecter) ReadBySlug(projectID interface{}, slug interface{}) *AssetRepository_ReadBySlug_Call

+ func (_e *AssetRepository_Expecter) Save(tx interface{}, t interface{}) *AssetRepository_Save_Call

+ func (_e *AssetRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *AssetRepository_SaveBatch_Call

+ func (_e *AssetRepository_Expecter) Transaction(_a0 interface{}) *AssetRepository_Transaction_Call

+ func (_e *AssetRepository_Expecter) Update(tx interface{}, _a1 interface{}) *AssetRepository_Update_Call

+ type AssetRepository_FindByName_Call struct

+ func (_c *AssetRepository_FindByName_Call) Return(_a0 models.Asset, _a1 error) *AssetRepository_FindByName_Call

+ func (_c *AssetRepository_FindByName_Call) Run(run func(name string)) *AssetRepository_FindByName_Call

+ func (_c *AssetRepository_FindByName_Call) RunAndReturn(run func(string) (models.Asset, error)) *AssetRepository_FindByName_Call

+ type AssetRepository_FindOrCreate_Call struct

+ func (_c *AssetRepository_FindOrCreate_Call) Return(_a0 models.Asset, _a1 error) *AssetRepository_FindOrCreate_Call

+ func (_c *AssetRepository_FindOrCreate_Call) Run(run func(tx *gorm.DB, name string)) *AssetRepository_FindOrCreate_Call

+ func (_c *AssetRepository_FindOrCreate_Call) RunAndReturn(run func(*gorm.DB, string) (models.Asset, error)) *AssetRepository_FindOrCreate_Call

+ type AssetRepository_GetAssetIDBySlug_Call struct

+ func (_c *AssetRepository_GetAssetIDBySlug_Call) Return(_a0 uuid.UUID, _a1 error) *AssetRepository_GetAssetIDBySlug_Call

+ func (_c *AssetRepository_GetAssetIDBySlug_Call) Run(run func(projectID uuid.UUID, slug string)) *AssetRepository_GetAssetIDBySlug_Call

+ func (_c *AssetRepository_GetAssetIDBySlug_Call) RunAndReturn(run func(uuid.UUID, string) (uuid.UUID, error)) *AssetRepository_GetAssetIDBySlug_Call

+ type AssetRepository_GetByProjectID_Call struct

+ func (_c *AssetRepository_GetByProjectID_Call) Return(_a0 []models.Asset, _a1 error) *AssetRepository_GetByProjectID_Call

+ func (_c *AssetRepository_GetByProjectID_Call) Run(run func(projectID uuid.UUID)) *AssetRepository_GetByProjectID_Call

+ func (_c *AssetRepository_GetByProjectID_Call) RunAndReturn(run func(uuid.UUID) ([]models.Asset, error)) *AssetRepository_GetByProjectID_Call

+ type AssetRepository_GetDB_Call struct

+ func (_c *AssetRepository_GetDB_Call) Return(_a0 *gorm.DB) *AssetRepository_GetDB_Call

+ func (_c *AssetRepository_GetDB_Call) Run(run func(tx *gorm.DB)) *AssetRepository_GetDB_Call

+ func (_c *AssetRepository_GetDB_Call) RunAndReturn(run func(*gorm.DB) *gorm.DB) *AssetRepository_GetDB_Call

+ type AssetRepository_List_Call struct

+ func (_c *AssetRepository_List_Call) Return(_a0 []models.Asset, _a1 error) *AssetRepository_List_Call

+ func (_c *AssetRepository_List_Call) Run(run func(ids []uuid.UUID)) *AssetRepository_List_Call

+ func (_c *AssetRepository_List_Call) RunAndReturn(run func([]uuid.UUID) ([]models.Asset, error)) *AssetRepository_List_Call

+ type AssetRepository_ReadBySlug_Call struct

+ func (_c *AssetRepository_ReadBySlug_Call) Return(_a0 models.Asset, _a1 error) *AssetRepository_ReadBySlug_Call

+ func (_c *AssetRepository_ReadBySlug_Call) Run(run func(projectID uuid.UUID, slug string)) *AssetRepository_ReadBySlug_Call

+ func (_c *AssetRepository_ReadBySlug_Call) RunAndReturn(run func(uuid.UUID, string) (models.Asset, error)) *AssetRepository_ReadBySlug_Call

+ type AssetRepository_Read_Call struct

+ func (_c *AssetRepository_Read_Call) Return(_a0 models.Asset, _a1 error) *AssetRepository_Read_Call

+ func (_c *AssetRepository_Read_Call) Run(run func(id uuid.UUID)) *AssetRepository_Read_Call

+ func (_c *AssetRepository_Read_Call) RunAndReturn(run func(uuid.UUID) (models.Asset, error)) *AssetRepository_Read_Call

+ type AssetRepository_SaveBatch_Call struct

+ func (_c *AssetRepository_SaveBatch_Call) Return(_a0 error) *AssetRepository_SaveBatch_Call

+ func (_c *AssetRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, ts []models.Asset)) *AssetRepository_SaveBatch_Call

+ func (_c *AssetRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Asset) error) *AssetRepository_SaveBatch_Call

+ type AssetRepository_Save_Call struct

+ func (_c *AssetRepository_Save_Call) Return(_a0 error) *AssetRepository_Save_Call

+ func (_c *AssetRepository_Save_Call) Run(run func(tx *gorm.DB, t *models.Asset)) *AssetRepository_Save_Call

+ func (_c *AssetRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.Asset) error) *AssetRepository_Save_Call

+ type AssetRepository_Transaction_Call struct

+ func (_c *AssetRepository_Transaction_Call) Return(_a0 error) *AssetRepository_Transaction_Call

+ func (_c *AssetRepository_Transaction_Call) Run(run func(_a0 func(*gorm.DB) error)) *AssetRepository_Transaction_Call

+ func (_c *AssetRepository_Transaction_Call) RunAndReturn(run func(func(*gorm.DB) error) error) *AssetRepository_Transaction_Call

+ type AssetRepository_Update_Call struct

+ func (_c *AssetRepository_Update_Call) Return(_a0 error) *AssetRepository_Update_Call

+ func (_c *AssetRepository_Update_Call) Run(run func(tx *gorm.DB, _a1 *models.Asset)) *AssetRepository_Update_Call

+ func (_c *AssetRepository_Update_Call) RunAndReturn(run func(*gorm.DB, *models.Asset) error) *AssetRepository_Update_Call

+ type AssetVulnService struct

+ func NewAssetVulnService(t interface{ ... }) *AssetVulnService

+ func (_m *AssetVulnService) EXPECT() *AssetVulnService_Expecter

+ func (_m *AssetVulnService) GetVulnsForAll(purls []string) ([]models.VulnInPackage, error)

+ type AssetVulnService_Expecter struct

+ func (_e *AssetVulnService_Expecter) GetVulnsForAll(purls interface{}) *AssetVulnService_GetVulnsForAll_Call

+ type AssetVulnService_GetVulnsForAll_Call struct

+ func (_c *AssetVulnService_GetVulnsForAll_Call) Return(_a0 []models.VulnInPackage, _a1 error) *AssetVulnService_GetVulnsForAll_Call

+ func (_c *AssetVulnService_GetVulnsForAll_Call) Run(run func(purls []string)) *AssetVulnService_GetVulnsForAll_Call

+ func (_c *AssetVulnService_GetVulnsForAll_Call) RunAndReturn(run func([]string) ([]models.VulnInPackage, error)) *AssetVulnService_GetVulnsForAll_Call

+ type ConfigConfigRepository struct

+ func NewConfigConfigRepository(t interface{ ... }) *ConfigConfigRepository

+ func (_m *ConfigConfigRepository) EXPECT() *ConfigConfigRepository_Expecter

+ func (_m *ConfigConfigRepository) GetDB(tx *gorm.DB) *gorm.DB

+ func (_m *ConfigConfigRepository) Save(tx *gorm.DB, _a1 *models.Config) error

+ type ConfigConfigRepository_Expecter struct

+ func (_e *ConfigConfigRepository_Expecter) GetDB(tx interface{}) *ConfigConfigRepository_GetDB_Call

+ func (_e *ConfigConfigRepository_Expecter) Save(tx interface{}, _a1 interface{}) *ConfigConfigRepository_Save_Call

+ type ConfigConfigRepository_GetDB_Call struct

+ func (_c *ConfigConfigRepository_GetDB_Call) Return(_a0 *gorm.DB) *ConfigConfigRepository_GetDB_Call

+ func (_c *ConfigConfigRepository_GetDB_Call) Run(run func(tx *gorm.DB)) *ConfigConfigRepository_GetDB_Call

+ func (_c *ConfigConfigRepository_GetDB_Call) RunAndReturn(run func(*gorm.DB) *gorm.DB) *ConfigConfigRepository_GetDB_Call

+ type ConfigConfigRepository_Save_Call struct

+ func (_c *ConfigConfigRepository_Save_Call) Return(_a0 error) *ConfigConfigRepository_Save_Call

+ func (_c *ConfigConfigRepository_Save_Call) Run(run func(tx *gorm.DB, _a1 *models.Config)) *ConfigConfigRepository_Save_Call

+ func (_c *ConfigConfigRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.Config) error) *ConfigConfigRepository_Save_Call

+ type CoreAuthSession struct

+ func NewCoreAuthSession(t interface{ ... }) *CoreAuthSession

+ func (_m *CoreAuthSession) EXPECT() *CoreAuthSession_Expecter

+ func (_m *CoreAuthSession) GetUserID() string

+ type CoreAuthSession_Expecter struct

+ func (_e *CoreAuthSession_Expecter) GetUserID() *CoreAuthSession_GetUserID_Call

+ type CoreAuthSession_GetUserID_Call struct

+ func (_c *CoreAuthSession_GetUserID_Call) Return(_a0 string) *CoreAuthSession_GetUserID_Call

+ func (_c *CoreAuthSession_GetUserID_Call) Run(run func()) *CoreAuthSession_GetUserID_Call

+ func (_c *CoreAuthSession_GetUserID_Call) RunAndReturn(run func() string) *CoreAuthSession_GetUserID_Call

+ type FlawAssetRepository struct

+ func NewFlawAssetRepository(t interface{ ... }) *FlawAssetRepository

+ func (_m *FlawAssetRepository) EXPECT() *FlawAssetRepository_Expecter

+ func (_m *FlawAssetRepository) GetAllAssetsFromDB() ([]models.Asset, error)

+ func (_m *FlawAssetRepository) Update(tx *gorm.DB, asset *models.Asset) error

+ type FlawAssetRepository_Expecter struct

+ func (_e *FlawAssetRepository_Expecter) GetAllAssetsFromDB() *FlawAssetRepository_GetAllAssetsFromDB_Call

+ func (_e *FlawAssetRepository_Expecter) Update(tx interface{}, asset interface{}) *FlawAssetRepository_Update_Call

+ type FlawAssetRepository_GetAllAssetsFromDB_Call struct

+ func (_c *FlawAssetRepository_GetAllAssetsFromDB_Call) Return(_a0 []models.Asset, _a1 error) *FlawAssetRepository_GetAllAssetsFromDB_Call

+ func (_c *FlawAssetRepository_GetAllAssetsFromDB_Call) Run(run func()) *FlawAssetRepository_GetAllAssetsFromDB_Call

+ func (_c *FlawAssetRepository_GetAllAssetsFromDB_Call) RunAndReturn(run func() ([]models.Asset, error)) *FlawAssetRepository_GetAllAssetsFromDB_Call

+ type FlawAssetRepository_Update_Call struct

+ func (_c *FlawAssetRepository_Update_Call) Return(_a0 error) *FlawAssetRepository_Update_Call

+ func (_c *FlawAssetRepository_Update_Call) Run(run func(tx *gorm.DB, asset *models.Asset)) *FlawAssetRepository_Update_Call

+ func (_c *FlawAssetRepository_Update_Call) RunAndReturn(run func(*gorm.DB, *models.Asset) error) *FlawAssetRepository_Update_Call

+ type FlawCtrFlawEventRepository struct

+ func NewFlawCtrFlawEventRepository(t interface{ ... }) *FlawCtrFlawEventRepository

+ func (_m *FlawCtrFlawEventRepository) Create(tx *gorm.DB, flawEvent *models.FlawEvent) error

+ func (_m *FlawCtrFlawEventRepository) EXPECT() *FlawCtrFlawEventRepository_Expecter

+ type FlawCtrFlawEventRepository_Create_Call struct

+ func (_c *FlawCtrFlawEventRepository_Create_Call) Return(_a0 error) *FlawCtrFlawEventRepository_Create_Call

+ func (_c *FlawCtrFlawEventRepository_Create_Call) Run(run func(tx *gorm.DB, flawEvent *models.FlawEvent)) *FlawCtrFlawEventRepository_Create_Call

+ func (_c *FlawCtrFlawEventRepository_Create_Call) RunAndReturn(run func(*gorm.DB, *models.FlawEvent) error) *FlawCtrFlawEventRepository_Create_Call

+ type FlawCtrFlawEventRepository_Expecter struct

+ func (_e *FlawCtrFlawEventRepository_Expecter) Create(tx interface{}, flawEvent interface{}) *FlawCtrFlawEventRepository_Create_Call

+ type FlawCveRepository struct

+ func NewFlawCveRepository(t interface{ ... }) *FlawCveRepository

+ func (_m *FlawCveRepository) EXPECT() *FlawCveRepository_Expecter

+ func (_m *FlawCveRepository) FindCVE(tx *gorm.DB, cveId string) (interface{}, error)

+ type FlawCveRepository_Expecter struct

+ func (_e *FlawCveRepository_Expecter) FindCVE(tx interface{}, cveId interface{}) *FlawCveRepository_FindCVE_Call

+ type FlawCveRepository_FindCVE_Call struct

+ func (_c *FlawCveRepository_FindCVE_Call) Return(_a0 interface{}, _a1 error) *FlawCveRepository_FindCVE_Call

+ func (_c *FlawCveRepository_FindCVE_Call) Run(run func(tx *gorm.DB, cveId string)) *FlawCveRepository_FindCVE_Call

+ func (_c *FlawCveRepository_FindCVE_Call) RunAndReturn(run func(*gorm.DB, string) (interface{}, error)) *FlawCveRepository_FindCVE_Call

+ type FlawFlawEventRepository struct

+ func NewFlawFlawEventRepository(t interface{ ... }) *FlawFlawEventRepository

+ func (_m *FlawFlawEventRepository) EXPECT() *FlawFlawEventRepository_Expecter

+ func (_m *FlawFlawEventRepository) Save(db *gorm.DB, event *models.FlawEvent) error

+ func (_m *FlawFlawEventRepository) SaveBatch(db *gorm.DB, events []models.FlawEvent) error

+ type FlawFlawEventRepository_Expecter struct

+ func (_e *FlawFlawEventRepository_Expecter) Save(db interface{}, event interface{}) *FlawFlawEventRepository_Save_Call

+ func (_e *FlawFlawEventRepository_Expecter) SaveBatch(db interface{}, events interface{}) *FlawFlawEventRepository_SaveBatch_Call

+ type FlawFlawEventRepository_SaveBatch_Call struct

+ func (_c *FlawFlawEventRepository_SaveBatch_Call) Return(_a0 error) *FlawFlawEventRepository_SaveBatch_Call

+ func (_c *FlawFlawEventRepository_SaveBatch_Call) Run(run func(db *gorm.DB, events []models.FlawEvent)) *FlawFlawEventRepository_SaveBatch_Call

+ func (_c *FlawFlawEventRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.FlawEvent) error) *FlawFlawEventRepository_SaveBatch_Call

+ type FlawFlawEventRepository_Save_Call struct

+ func (_c *FlawFlawEventRepository_Save_Call) Return(_a0 error) *FlawFlawEventRepository_Save_Call

+ func (_c *FlawFlawEventRepository_Save_Call) Run(run func(db *gorm.DB, event *models.FlawEvent)) *FlawFlawEventRepository_Save_Call

+ func (_c *FlawFlawEventRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.FlawEvent) error) *FlawFlawEventRepository_Save_Call

+ type FlawFlawRepository struct

+ func NewFlawFlawRepository(t interface{ ... }) *FlawFlawRepository

+ func (_m *FlawFlawRepository) Begin() *gorm.DB

+ func (_m *FlawFlawRepository) EXPECT() *FlawFlawRepository_Expecter

+ func (_m *FlawFlawRepository) GetAllFlawsByAssetID(tx *gorm.DB, assetID uuid.UUID) ([]models.Flaw, error)

+ func (_m *FlawFlawRepository) Save(db *gorm.DB, flaws *models.Flaw) error

+ func (_m *FlawFlawRepository) SaveBatch(db *gorm.DB, flaws []models.Flaw) error

+ func (_m *FlawFlawRepository) Transaction(txFunc func(*gorm.DB) error) error

+ type FlawFlawRepository_Begin_Call struct

+ func (_c *FlawFlawRepository_Begin_Call) Return(_a0 *gorm.DB) *FlawFlawRepository_Begin_Call

+ func (_c *FlawFlawRepository_Begin_Call) Run(run func()) *FlawFlawRepository_Begin_Call

+ func (_c *FlawFlawRepository_Begin_Call) RunAndReturn(run func() *gorm.DB) *FlawFlawRepository_Begin_Call

+ type FlawFlawRepository_Expecter struct

+ func (_e *FlawFlawRepository_Expecter) Begin() *FlawFlawRepository_Begin_Call

+ func (_e *FlawFlawRepository_Expecter) GetAllFlawsByAssetID(tx interface{}, assetID interface{}) *FlawFlawRepository_GetAllFlawsByAssetID_Call

+ func (_e *FlawFlawRepository_Expecter) Save(db interface{}, flaws interface{}) *FlawFlawRepository_Save_Call

+ func (_e *FlawFlawRepository_Expecter) SaveBatch(db interface{}, flaws interface{}) *FlawFlawRepository_SaveBatch_Call

+ func (_e *FlawFlawRepository_Expecter) Transaction(txFunc interface{}) *FlawFlawRepository_Transaction_Call

+ type FlawFlawRepository_GetAllFlawsByAssetID_Call struct

+ func (_c *FlawFlawRepository_GetAllFlawsByAssetID_Call) Return(_a0 []models.Flaw, _a1 error) *FlawFlawRepository_GetAllFlawsByAssetID_Call

+ func (_c *FlawFlawRepository_GetAllFlawsByAssetID_Call) Run(run func(tx *gorm.DB, assetID uuid.UUID)) *FlawFlawRepository_GetAllFlawsByAssetID_Call

+ func (_c *FlawFlawRepository_GetAllFlawsByAssetID_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) ([]models.Flaw, error)) *FlawFlawRepository_GetAllFlawsByAssetID_Call

+ type FlawFlawRepository_SaveBatch_Call struct

+ func (_c *FlawFlawRepository_SaveBatch_Call) Return(_a0 error) *FlawFlawRepository_SaveBatch_Call

+ func (_c *FlawFlawRepository_SaveBatch_Call) Run(run func(db *gorm.DB, flaws []models.Flaw)) *FlawFlawRepository_SaveBatch_Call

+ func (_c *FlawFlawRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Flaw) error) *FlawFlawRepository_SaveBatch_Call

+ type FlawFlawRepository_Save_Call struct

+ func (_c *FlawFlawRepository_Save_Call) Return(_a0 error) *FlawFlawRepository_Save_Call

+ func (_c *FlawFlawRepository_Save_Call) Run(run func(db *gorm.DB, flaws *models.Flaw)) *FlawFlawRepository_Save_Call

+ func (_c *FlawFlawRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.Flaw) error) *FlawFlawRepository_Save_Call

+ type FlawFlawRepository_Transaction_Call struct

+ func (_c *FlawFlawRepository_Transaction_Call) Return(_a0 error) *FlawFlawRepository_Transaction_Call

+ func (_c *FlawFlawRepository_Transaction_Call) Run(run func(txFunc func(*gorm.DB) error)) *FlawFlawRepository_Transaction_Call

+ func (_c *FlawFlawRepository_Transaction_Call) RunAndReturn(run func(func(*gorm.DB) error) error) *FlawFlawRepository_Transaction_Call

+ type FlawFlawService struct

+ func NewFlawFlawService(t interface{ ... }) *FlawFlawService

+ func (_m *FlawFlawService) EXPECT() *FlawFlawService_Expecter

+ func (_m *FlawFlawService) UpdateFlawState(tx *gorm.DB, userID string, _a2 *models.Flaw, statusType string, ...) error

+ type FlawFlawService_Expecter struct

+ func (_e *FlawFlawService_Expecter) UpdateFlawState(tx interface{}, userID interface{}, _a2 interface{}, statusType interface{}, ...) *FlawFlawService_UpdateFlawState_Call

+ type FlawFlawService_UpdateFlawState_Call struct

+ func (_c *FlawFlawService_UpdateFlawState_Call) Return(_a0 error) *FlawFlawService_UpdateFlawState_Call

+ func (_c *FlawFlawService_UpdateFlawState_Call) Run(run func(tx *gorm.DB, userID string, _a2 *models.Flaw, statusType string, ...)) *FlawFlawService_UpdateFlawState_Call

+ func (_c *FlawFlawService_UpdateFlawState_Call) RunAndReturn(run func(*gorm.DB, string, *models.Flaw, string, *string) error) *FlawFlawService_UpdateFlawState_Call

+ type FlawRepository struct

+ func NewFlawRepository(t interface{ ... }) *FlawRepository

+ func (_m *FlawRepository) Begin() *gorm.DB

+ func (_m *FlawRepository) Create(tx *gorm.DB, t *models.Flaw) error

+ func (_m *FlawRepository) CreateBatch(tx *gorm.DB, ts []models.Flaw) error

+ func (_m *FlawRepository) Delete(tx *gorm.DB, id string) error

+ func (_m *FlawRepository) EXPECT() *FlawRepository_Expecter

+ func (_m *FlawRepository) GetByAssetId(tx *gorm.DB, assetId uuid.UUID) ([]models.Flaw, error)

+ func (_m *FlawRepository) GetByAssetIdPaged(tx *gorm.DB, pageInfo core.PageInfo, filter []core.FilterQuery, ...) (core.Paged[models.Flaw], error)

+ func (_m *FlawRepository) GetDB(tx *gorm.DB) *gorm.DB

+ func (_m *FlawRepository) List(ids []string) ([]models.Flaw, error)

+ func (_m *FlawRepository) Read(id string) (models.Flaw, error)

+ func (_m *FlawRepository) Save(tx *gorm.DB, t *models.Flaw) error

+ func (_m *FlawRepository) SaveBatch(tx *gorm.DB, ts []models.Flaw) error

+ func (_m *FlawRepository) Transaction(_a0 func(*gorm.DB) error) error

+ type FlawRepository_Begin_Call struct

+ func (_c *FlawRepository_Begin_Call) Return(_a0 *gorm.DB) *FlawRepository_Begin_Call

+ func (_c *FlawRepository_Begin_Call) Run(run func()) *FlawRepository_Begin_Call

+ func (_c *FlawRepository_Begin_Call) RunAndReturn(run func() *gorm.DB) *FlawRepository_Begin_Call

+ type FlawRepository_CreateBatch_Call struct

+ func (_c *FlawRepository_CreateBatch_Call) Return(_a0 error) *FlawRepository_CreateBatch_Call

+ func (_c *FlawRepository_CreateBatch_Call) Run(run func(tx *gorm.DB, ts []models.Flaw)) *FlawRepository_CreateBatch_Call

+ func (_c *FlawRepository_CreateBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Flaw) error) *FlawRepository_CreateBatch_Call

+ type FlawRepository_Create_Call struct

+ func (_c *FlawRepository_Create_Call) Return(_a0 error) *FlawRepository_Create_Call

+ func (_c *FlawRepository_Create_Call) Run(run func(tx *gorm.DB, t *models.Flaw)) *FlawRepository_Create_Call

+ func (_c *FlawRepository_Create_Call) RunAndReturn(run func(*gorm.DB, *models.Flaw) error) *FlawRepository_Create_Call

+ type FlawRepository_Delete_Call struct

+ func (_c *FlawRepository_Delete_Call) Return(_a0 error) *FlawRepository_Delete_Call

+ func (_c *FlawRepository_Delete_Call) Run(run func(tx *gorm.DB, id string)) *FlawRepository_Delete_Call

+ func (_c *FlawRepository_Delete_Call) RunAndReturn(run func(*gorm.DB, string) error) *FlawRepository_Delete_Call

+ type FlawRepository_Expecter struct

+ func (_e *FlawRepository_Expecter) Begin() *FlawRepository_Begin_Call

+ func (_e *FlawRepository_Expecter) Create(tx interface{}, t interface{}) *FlawRepository_Create_Call

+ func (_e *FlawRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *FlawRepository_CreateBatch_Call

+ func (_e *FlawRepository_Expecter) Delete(tx interface{}, id interface{}) *FlawRepository_Delete_Call

+ func (_e *FlawRepository_Expecter) GetByAssetId(tx interface{}, assetId interface{}) *FlawRepository_GetByAssetId_Call

+ func (_e *FlawRepository_Expecter) GetByAssetIdPaged(tx interface{}, pageInfo interface{}, filter interface{}, sort interface{}, ...) *FlawRepository_GetByAssetIdPaged_Call

+ func (_e *FlawRepository_Expecter) GetDB(tx interface{}) *FlawRepository_GetDB_Call

+ func (_e *FlawRepository_Expecter) List(ids interface{}) *FlawRepository_List_Call

+ func (_e *FlawRepository_Expecter) Read(id interface{}) *FlawRepository_Read_Call

+ func (_e *FlawRepository_Expecter) Save(tx interface{}, t interface{}) *FlawRepository_Save_Call

+ func (_e *FlawRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *FlawRepository_SaveBatch_Call

+ func (_e *FlawRepository_Expecter) Transaction(_a0 interface{}) *FlawRepository_Transaction_Call

+ type FlawRepository_GetByAssetIdPaged_Call struct

+ func (_c *FlawRepository_GetByAssetIdPaged_Call) Return(_a0 core.Paged[models.Flaw], _a1 error) *FlawRepository_GetByAssetIdPaged_Call

+ func (_c *FlawRepository_GetByAssetIdPaged_Call) Run(run func(tx *gorm.DB, pageInfo core.PageInfo, filter []core.FilterQuery, ...)) *FlawRepository_GetByAssetIdPaged_Call

+ func (_c *FlawRepository_GetByAssetIdPaged_Call) RunAndReturn(...) *FlawRepository_GetByAssetIdPaged_Call

+ type FlawRepository_GetByAssetId_Call struct

+ func (_c *FlawRepository_GetByAssetId_Call) Return(_a0 []models.Flaw, _a1 error) *FlawRepository_GetByAssetId_Call

+ func (_c *FlawRepository_GetByAssetId_Call) Run(run func(tx *gorm.DB, assetId uuid.UUID)) *FlawRepository_GetByAssetId_Call

+ func (_c *FlawRepository_GetByAssetId_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) ([]models.Flaw, error)) *FlawRepository_GetByAssetId_Call

+ type FlawRepository_GetDB_Call struct

+ func (_c *FlawRepository_GetDB_Call) Return(_a0 *gorm.DB) *FlawRepository_GetDB_Call

+ func (_c *FlawRepository_GetDB_Call) Run(run func(tx *gorm.DB)) *FlawRepository_GetDB_Call

+ func (_c *FlawRepository_GetDB_Call) RunAndReturn(run func(*gorm.DB) *gorm.DB) *FlawRepository_GetDB_Call

+ type FlawRepository_List_Call struct

+ func (_c *FlawRepository_List_Call) Return(_a0 []models.Flaw, _a1 error) *FlawRepository_List_Call

+ func (_c *FlawRepository_List_Call) Run(run func(ids []string)) *FlawRepository_List_Call

+ func (_c *FlawRepository_List_Call) RunAndReturn(run func([]string) ([]models.Flaw, error)) *FlawRepository_List_Call

+ type FlawRepository_Read_Call struct

+ func (_c *FlawRepository_Read_Call) Return(_a0 models.Flaw, _a1 error) *FlawRepository_Read_Call

+ func (_c *FlawRepository_Read_Call) Run(run func(id string)) *FlawRepository_Read_Call

+ func (_c *FlawRepository_Read_Call) RunAndReturn(run func(string) (models.Flaw, error)) *FlawRepository_Read_Call

+ type FlawRepository_SaveBatch_Call struct

+ func (_c *FlawRepository_SaveBatch_Call) Return(_a0 error) *FlawRepository_SaveBatch_Call

+ func (_c *FlawRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, ts []models.Flaw)) *FlawRepository_SaveBatch_Call

+ func (_c *FlawRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Flaw) error) *FlawRepository_SaveBatch_Call

+ type FlawRepository_Save_Call struct

+ func (_c *FlawRepository_Save_Call) Return(_a0 error) *FlawRepository_Save_Call

+ func (_c *FlawRepository_Save_Call) Run(run func(tx *gorm.DB, t *models.Flaw)) *FlawRepository_Save_Call

+ func (_c *FlawRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.Flaw) error) *FlawRepository_Save_Call

+ type FlawRepository_Transaction_Call struct

+ func (_c *FlawRepository_Transaction_Call) Return(_a0 error) *FlawRepository_Transaction_Call

+ func (_c *FlawRepository_Transaction_Call) Run(run func(_a0 func(*gorm.DB) error)) *FlawRepository_Transaction_Call

+ func (_c *FlawRepository_Transaction_Call) RunAndReturn(run func(func(*gorm.DB) error) error) *FlawRepository_Transaction_Call

+ type IntegrationsGithubAppInstallationRepository struct

+ func NewIntegrationsGithubAppInstallationRepository(t interface{ ... }) *IntegrationsGithubAppInstallationRepository

+ func (_m *IntegrationsGithubAppInstallationRepository) EXPECT() *IntegrationsGithubAppInstallationRepository_Expecter

+ func (_m *IntegrationsGithubAppInstallationRepository) FindByOrganizationId(orgID uuid.UUID) ([]models.GithubAppInstallation, error)

+ func (_m *IntegrationsGithubAppInstallationRepository) Read(installationID int) (models.GithubAppInstallation, error)

+ func (_m *IntegrationsGithubAppInstallationRepository) Save(tx *gorm.DB, model *models.GithubAppInstallation) error

+ type IntegrationsGithubAppInstallationRepository_Expecter struct

+ func (_e *IntegrationsGithubAppInstallationRepository_Expecter) FindByOrganizationId(orgID interface{}) *IntegrationsGithubAppInstallationRepository_FindByOrganizationId_Call

+ func (_e *IntegrationsGithubAppInstallationRepository_Expecter) Read(installationID interface{}) *IntegrationsGithubAppInstallationRepository_Read_Call

+ func (_e *IntegrationsGithubAppInstallationRepository_Expecter) Save(tx interface{}, model interface{}) *IntegrationsGithubAppInstallationRepository_Save_Call

+ type IntegrationsGithubAppInstallationRepository_FindByOrganizationId_Call struct

+ func (_c *IntegrationsGithubAppInstallationRepository_FindByOrganizationId_Call) Return(_a0 []models.GithubAppInstallation, _a1 error) *IntegrationsGithubAppInstallationRepository_FindByOrganizationId_Call

+ func (_c *IntegrationsGithubAppInstallationRepository_FindByOrganizationId_Call) Run(run func(orgID uuid.UUID)) *IntegrationsGithubAppInstallationRepository_FindByOrganizationId_Call

+ func (_c *IntegrationsGithubAppInstallationRepository_FindByOrganizationId_Call) RunAndReturn(run func(uuid.UUID) ([]models.GithubAppInstallation, error)) *IntegrationsGithubAppInstallationRepository_FindByOrganizationId_Call

+ type IntegrationsGithubAppInstallationRepository_Read_Call struct

+ func (_c *IntegrationsGithubAppInstallationRepository_Read_Call) Return(_a0 models.GithubAppInstallation, _a1 error) *IntegrationsGithubAppInstallationRepository_Read_Call

+ func (_c *IntegrationsGithubAppInstallationRepository_Read_Call) Run(run func(installationID int)) *IntegrationsGithubAppInstallationRepository_Read_Call

+ func (_c *IntegrationsGithubAppInstallationRepository_Read_Call) RunAndReturn(run func(int) (models.GithubAppInstallation, error)) *IntegrationsGithubAppInstallationRepository_Read_Call

+ type IntegrationsGithubAppInstallationRepository_Save_Call struct

+ func (_c *IntegrationsGithubAppInstallationRepository_Save_Call) Return(_a0 error) *IntegrationsGithubAppInstallationRepository_Save_Call

+ func (_c *IntegrationsGithubAppInstallationRepository_Save_Call) Run(run func(tx *gorm.DB, model *models.GithubAppInstallation)) *IntegrationsGithubAppInstallationRepository_Save_Call

+ func (_c *IntegrationsGithubAppInstallationRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.GithubAppInstallation) error) *IntegrationsGithubAppInstallationRepository_Save_Call

+ type LeaderelectionConfigService struct

+ func NewLeaderelectionConfigService(t interface{ ... }) *LeaderelectionConfigService

+ func (_m *LeaderelectionConfigService) EXPECT() *LeaderelectionConfigService_Expecter

+ func (_m *LeaderelectionConfigService) GetJSONConfig(key string, v interface{}) error

+ func (_m *LeaderelectionConfigService) SetJSONConfig(key string, v interface{}) error

+ type LeaderelectionConfigService_Expecter struct

+ func (_e *LeaderelectionConfigService_Expecter) GetJSONConfig(key interface{}, v interface{}) *LeaderelectionConfigService_GetJSONConfig_Call

+ func (_e *LeaderelectionConfigService_Expecter) SetJSONConfig(key interface{}, v interface{}) *LeaderelectionConfigService_SetJSONConfig_Call

+ type LeaderelectionConfigService_GetJSONConfig_Call struct

+ func (_c *LeaderelectionConfigService_GetJSONConfig_Call) Return(_a0 error) *LeaderelectionConfigService_GetJSONConfig_Call

+ func (_c *LeaderelectionConfigService_GetJSONConfig_Call) Run(run func(key string, v interface{})) *LeaderelectionConfigService_GetJSONConfig_Call

+ func (_c *LeaderelectionConfigService_GetJSONConfig_Call) RunAndReturn(run func(string, interface{}) error) *LeaderelectionConfigService_GetJSONConfig_Call

+ type LeaderelectionConfigService_SetJSONConfig_Call struct

+ func (_c *LeaderelectionConfigService_SetJSONConfig_Call) Return(_a0 error) *LeaderelectionConfigService_SetJSONConfig_Call

+ func (_c *LeaderelectionConfigService_SetJSONConfig_Call) Run(run func(key string, v interface{})) *LeaderelectionConfigService_SetJSONConfig_Call

+ func (_c *LeaderelectionConfigService_SetJSONConfig_Call) RunAndReturn(run func(string, interface{}) error) *LeaderelectionConfigService_SetJSONConfig_Call

+ type OrgRepository struct

+ func NewOrgRepository(t interface{ ... }) *OrgRepository

+ func (_m *OrgRepository) Begin() *gorm.DB

+ func (_m *OrgRepository) Create(tx *gorm.DB, t *models.Org) error

+ func (_m *OrgRepository) CreateBatch(tx *gorm.DB, ts []models.Org) error

+ func (_m *OrgRepository) Delete(tx *gorm.DB, id uuid.UUID) error

+ func (_m *OrgRepository) EXPECT() *OrgRepository_Expecter

+ func (_m *OrgRepository) GetDB(tx *gorm.DB) *gorm.DB

+ func (_m *OrgRepository) List(ids []uuid.UUID) ([]models.Org, error)

+ func (_m *OrgRepository) Read(id uuid.UUID) (models.Org, error)

+ func (_m *OrgRepository) ReadBySlug(slug string) (models.Org, error)

+ func (_m *OrgRepository) Save(tx *gorm.DB, t *models.Org) error

+ func (_m *OrgRepository) SaveBatch(tx *gorm.DB, ts []models.Org) error

+ func (_m *OrgRepository) Transaction(_a0 func(*gorm.DB) error) error

+ type OrgRepository_Begin_Call struct

+ func (_c *OrgRepository_Begin_Call) Return(_a0 *gorm.DB) *OrgRepository_Begin_Call

+ func (_c *OrgRepository_Begin_Call) Run(run func()) *OrgRepository_Begin_Call

+ func (_c *OrgRepository_Begin_Call) RunAndReturn(run func() *gorm.DB) *OrgRepository_Begin_Call

+ type OrgRepository_CreateBatch_Call struct

+ func (_c *OrgRepository_CreateBatch_Call) Return(_a0 error) *OrgRepository_CreateBatch_Call

+ func (_c *OrgRepository_CreateBatch_Call) Run(run func(tx *gorm.DB, ts []models.Org)) *OrgRepository_CreateBatch_Call

+ func (_c *OrgRepository_CreateBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Org) error) *OrgRepository_CreateBatch_Call

+ type OrgRepository_Create_Call struct

+ func (_c *OrgRepository_Create_Call) Return(_a0 error) *OrgRepository_Create_Call

+ func (_c *OrgRepository_Create_Call) Run(run func(tx *gorm.DB, t *models.Org)) *OrgRepository_Create_Call

+ func (_c *OrgRepository_Create_Call) RunAndReturn(run func(*gorm.DB, *models.Org) error) *OrgRepository_Create_Call

+ type OrgRepository_Delete_Call struct

+ func (_c *OrgRepository_Delete_Call) Return(_a0 error) *OrgRepository_Delete_Call

+ func (_c *OrgRepository_Delete_Call) Run(run func(tx *gorm.DB, id uuid.UUID)) *OrgRepository_Delete_Call

+ func (_c *OrgRepository_Delete_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *OrgRepository_Delete_Call

+ type OrgRepository_Expecter struct

+ func (_e *OrgRepository_Expecter) Begin() *OrgRepository_Begin_Call

+ func (_e *OrgRepository_Expecter) Create(tx interface{}, t interface{}) *OrgRepository_Create_Call

+ func (_e *OrgRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *OrgRepository_CreateBatch_Call

+ func (_e *OrgRepository_Expecter) Delete(tx interface{}, id interface{}) *OrgRepository_Delete_Call

+ func (_e *OrgRepository_Expecter) GetDB(tx interface{}) *OrgRepository_GetDB_Call

+ func (_e *OrgRepository_Expecter) List(ids interface{}) *OrgRepository_List_Call

+ func (_e *OrgRepository_Expecter) Read(id interface{}) *OrgRepository_Read_Call

+ func (_e *OrgRepository_Expecter) ReadBySlug(slug interface{}) *OrgRepository_ReadBySlug_Call

+ func (_e *OrgRepository_Expecter) Save(tx interface{}, t interface{}) *OrgRepository_Save_Call

+ func (_e *OrgRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *OrgRepository_SaveBatch_Call

+ func (_e *OrgRepository_Expecter) Transaction(_a0 interface{}) *OrgRepository_Transaction_Call

+ type OrgRepository_GetDB_Call struct

+ func (_c *OrgRepository_GetDB_Call) Return(_a0 *gorm.DB) *OrgRepository_GetDB_Call

+ func (_c *OrgRepository_GetDB_Call) Run(run func(tx *gorm.DB)) *OrgRepository_GetDB_Call

+ func (_c *OrgRepository_GetDB_Call) RunAndReturn(run func(*gorm.DB) *gorm.DB) *OrgRepository_GetDB_Call

+ type OrgRepository_List_Call struct

+ func (_c *OrgRepository_List_Call) Return(_a0 []models.Org, _a1 error) *OrgRepository_List_Call

+ func (_c *OrgRepository_List_Call) Run(run func(ids []uuid.UUID)) *OrgRepository_List_Call

+ func (_c *OrgRepository_List_Call) RunAndReturn(run func([]uuid.UUID) ([]models.Org, error)) *OrgRepository_List_Call

+ type OrgRepository_ReadBySlug_Call struct

+ func (_c *OrgRepository_ReadBySlug_Call) Return(_a0 models.Org, _a1 error) *OrgRepository_ReadBySlug_Call

+ func (_c *OrgRepository_ReadBySlug_Call) Run(run func(slug string)) *OrgRepository_ReadBySlug_Call

+ func (_c *OrgRepository_ReadBySlug_Call) RunAndReturn(run func(string) (models.Org, error)) *OrgRepository_ReadBySlug_Call

+ type OrgRepository_Read_Call struct

+ func (_c *OrgRepository_Read_Call) Return(_a0 models.Org, _a1 error) *OrgRepository_Read_Call

+ func (_c *OrgRepository_Read_Call) Run(run func(id uuid.UUID)) *OrgRepository_Read_Call

+ func (_c *OrgRepository_Read_Call) RunAndReturn(run func(uuid.UUID) (models.Org, error)) *OrgRepository_Read_Call

+ type OrgRepository_SaveBatch_Call struct

+ func (_c *OrgRepository_SaveBatch_Call) Return(_a0 error) *OrgRepository_SaveBatch_Call

+ func (_c *OrgRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, ts []models.Org)) *OrgRepository_SaveBatch_Call

+ func (_c *OrgRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Org) error) *OrgRepository_SaveBatch_Call

+ type OrgRepository_Save_Call struct

+ func (_c *OrgRepository_Save_Call) Return(_a0 error) *OrgRepository_Save_Call

+ func (_c *OrgRepository_Save_Call) Run(run func(tx *gorm.DB, t *models.Org)) *OrgRepository_Save_Call

+ func (_c *OrgRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.Org) error) *OrgRepository_Save_Call

+ type OrgRepository_Transaction_Call struct

+ func (_c *OrgRepository_Transaction_Call) Return(_a0 error) *OrgRepository_Transaction_Call

+ func (_c *OrgRepository_Transaction_Call) Run(run func(_a0 func(*gorm.DB) error)) *OrgRepository_Transaction_Call

+ func (_c *OrgRepository_Transaction_Call) RunAndReturn(run func(func(*gorm.DB) error) error) *OrgRepository_Transaction_Call

+ type PatRepository struct

+ func NewPatRepository(t interface{ ... }) *PatRepository

+ func (_m *PatRepository) Begin() *gorm.DB

+ func (_m *PatRepository) Create(tx *gorm.DB, t *models.PAT) error

+ func (_m *PatRepository) CreateBatch(tx *gorm.DB, ts []models.PAT) error

+ func (_m *PatRepository) Delete(tx *gorm.DB, id uuid.UUID) error

+ func (_m *PatRepository) EXPECT() *PatRepository_Expecter

+ func (_m *PatRepository) GetByFingerprint(fingerprint string) (models.PAT, error)

+ func (_m *PatRepository) GetDB(tx *gorm.DB) *gorm.DB

+ func (_m *PatRepository) GetUserIDByToken(token string) (string, error)

+ func (_m *PatRepository) List(ids []uuid.UUID) ([]models.PAT, error)

+ func (_m *PatRepository) ListByUserID(userId string) ([]models.PAT, error)

+ func (_m *PatRepository) Read(id uuid.UUID) (models.PAT, error)

+ func (_m *PatRepository) ReadByToken(token string) (models.PAT, error)

+ func (_m *PatRepository) Save(tx *gorm.DB, t *models.PAT) error

+ func (_m *PatRepository) SaveBatch(tx *gorm.DB, ts []models.PAT) error

+ func (_m *PatRepository) Transaction(_a0 func(*gorm.DB) error) error

+ type PatRepository_Begin_Call struct

+ func (_c *PatRepository_Begin_Call) Return(_a0 *gorm.DB) *PatRepository_Begin_Call

+ func (_c *PatRepository_Begin_Call) Run(run func()) *PatRepository_Begin_Call

+ func (_c *PatRepository_Begin_Call) RunAndReturn(run func() *gorm.DB) *PatRepository_Begin_Call

+ type PatRepository_CreateBatch_Call struct

+ func (_c *PatRepository_CreateBatch_Call) Return(_a0 error) *PatRepository_CreateBatch_Call

+ func (_c *PatRepository_CreateBatch_Call) Run(run func(tx *gorm.DB, ts []models.PAT)) *PatRepository_CreateBatch_Call

+ func (_c *PatRepository_CreateBatch_Call) RunAndReturn(run func(*gorm.DB, []models.PAT) error) *PatRepository_CreateBatch_Call

+ type PatRepository_Create_Call struct

+ func (_c *PatRepository_Create_Call) Return(_a0 error) *PatRepository_Create_Call

+ func (_c *PatRepository_Create_Call) Run(run func(tx *gorm.DB, t *models.PAT)) *PatRepository_Create_Call

+ func (_c *PatRepository_Create_Call) RunAndReturn(run func(*gorm.DB, *models.PAT) error) *PatRepository_Create_Call

+ type PatRepository_Delete_Call struct

+ func (_c *PatRepository_Delete_Call) Return(_a0 error) *PatRepository_Delete_Call

+ func (_c *PatRepository_Delete_Call) Run(run func(tx *gorm.DB, id uuid.UUID)) *PatRepository_Delete_Call

+ func (_c *PatRepository_Delete_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *PatRepository_Delete_Call

+ type PatRepository_Expecter struct

+ func (_e *PatRepository_Expecter) Begin() *PatRepository_Begin_Call

+ func (_e *PatRepository_Expecter) Create(tx interface{}, t interface{}) *PatRepository_Create_Call

+ func (_e *PatRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *PatRepository_CreateBatch_Call

+ func (_e *PatRepository_Expecter) Delete(tx interface{}, id interface{}) *PatRepository_Delete_Call

+ func (_e *PatRepository_Expecter) GetByFingerprint(fingerprint interface{}) *PatRepository_GetByFingerprint_Call

+ func (_e *PatRepository_Expecter) GetDB(tx interface{}) *PatRepository_GetDB_Call

+ func (_e *PatRepository_Expecter) GetUserIDByToken(token interface{}) *PatRepository_GetUserIDByToken_Call

+ func (_e *PatRepository_Expecter) List(ids interface{}) *PatRepository_List_Call

+ func (_e *PatRepository_Expecter) ListByUserID(userId interface{}) *PatRepository_ListByUserID_Call

+ func (_e *PatRepository_Expecter) Read(id interface{}) *PatRepository_Read_Call

+ func (_e *PatRepository_Expecter) ReadByToken(token interface{}) *PatRepository_ReadByToken_Call

+ func (_e *PatRepository_Expecter) Save(tx interface{}, t interface{}) *PatRepository_Save_Call

+ func (_e *PatRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *PatRepository_SaveBatch_Call

+ func (_e *PatRepository_Expecter) Transaction(_a0 interface{}) *PatRepository_Transaction_Call

+ type PatRepository_GetByFingerprint_Call struct

+ func (_c *PatRepository_GetByFingerprint_Call) Return(_a0 models.PAT, _a1 error) *PatRepository_GetByFingerprint_Call

+ func (_c *PatRepository_GetByFingerprint_Call) Run(run func(fingerprint string)) *PatRepository_GetByFingerprint_Call

+ func (_c *PatRepository_GetByFingerprint_Call) RunAndReturn(run func(string) (models.PAT, error)) *PatRepository_GetByFingerprint_Call

+ type PatRepository_GetDB_Call struct

+ func (_c *PatRepository_GetDB_Call) Return(_a0 *gorm.DB) *PatRepository_GetDB_Call

+ func (_c *PatRepository_GetDB_Call) Run(run func(tx *gorm.DB)) *PatRepository_GetDB_Call

+ func (_c *PatRepository_GetDB_Call) RunAndReturn(run func(*gorm.DB) *gorm.DB) *PatRepository_GetDB_Call

+ type PatRepository_GetUserIDByToken_Call struct

+ func (_c *PatRepository_GetUserIDByToken_Call) Return(_a0 string, _a1 error) *PatRepository_GetUserIDByToken_Call

+ func (_c *PatRepository_GetUserIDByToken_Call) Run(run func(token string)) *PatRepository_GetUserIDByToken_Call

+ func (_c *PatRepository_GetUserIDByToken_Call) RunAndReturn(run func(string) (string, error)) *PatRepository_GetUserIDByToken_Call

+ type PatRepository_ListByUserID_Call struct

+ func (_c *PatRepository_ListByUserID_Call) Return(_a0 []models.PAT, _a1 error) *PatRepository_ListByUserID_Call

+ func (_c *PatRepository_ListByUserID_Call) Run(run func(userId string)) *PatRepository_ListByUserID_Call

+ func (_c *PatRepository_ListByUserID_Call) RunAndReturn(run func(string) ([]models.PAT, error)) *PatRepository_ListByUserID_Call

+ type PatRepository_List_Call struct

+ func (_c *PatRepository_List_Call) Return(_a0 []models.PAT, _a1 error) *PatRepository_List_Call

+ func (_c *PatRepository_List_Call) Run(run func(ids []uuid.UUID)) *PatRepository_List_Call

+ func (_c *PatRepository_List_Call) RunAndReturn(run func([]uuid.UUID) ([]models.PAT, error)) *PatRepository_List_Call

+ type PatRepository_ReadByToken_Call struct

+ func (_c *PatRepository_ReadByToken_Call) Return(_a0 models.PAT, _a1 error) *PatRepository_ReadByToken_Call

+ func (_c *PatRepository_ReadByToken_Call) Run(run func(token string)) *PatRepository_ReadByToken_Call

+ func (_c *PatRepository_ReadByToken_Call) RunAndReturn(run func(string) (models.PAT, error)) *PatRepository_ReadByToken_Call

+ type PatRepository_Read_Call struct

+ func (_c *PatRepository_Read_Call) Return(_a0 models.PAT, _a1 error) *PatRepository_Read_Call

+ func (_c *PatRepository_Read_Call) Run(run func(id uuid.UUID)) *PatRepository_Read_Call

+ func (_c *PatRepository_Read_Call) RunAndReturn(run func(uuid.UUID) (models.PAT, error)) *PatRepository_Read_Call

+ type PatRepository_SaveBatch_Call struct

+ func (_c *PatRepository_SaveBatch_Call) Return(_a0 error) *PatRepository_SaveBatch_Call

+ func (_c *PatRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, ts []models.PAT)) *PatRepository_SaveBatch_Call

+ func (_c *PatRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.PAT) error) *PatRepository_SaveBatch_Call

+ type PatRepository_Save_Call struct

+ func (_c *PatRepository_Save_Call) Return(_a0 error) *PatRepository_Save_Call

+ func (_c *PatRepository_Save_Call) Run(run func(tx *gorm.DB, t *models.PAT)) *PatRepository_Save_Call

+ func (_c *PatRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.PAT) error) *PatRepository_Save_Call

+ type PatRepository_Transaction_Call struct

+ func (_c *PatRepository_Transaction_Call) Return(_a0 error) *PatRepository_Transaction_Call

+ func (_c *PatRepository_Transaction_Call) Run(run func(_a0 func(*gorm.DB) error)) *PatRepository_Transaction_Call

+ func (_c *PatRepository_Transaction_Call) RunAndReturn(run func(func(*gorm.DB) error) error) *PatRepository_Transaction_Call

+ type ProjectAssetRepository struct

+ func NewProjectAssetRepository(t interface{ ... }) *ProjectAssetRepository

+ func (_m *ProjectAssetRepository) EXPECT() *ProjectAssetRepository_Expecter

+ func (_m *ProjectAssetRepository) GetByProjectID(projectID uuid.UUID) ([]models.Asset, error)

+ type ProjectAssetRepository_Expecter struct

+ func (_e *ProjectAssetRepository_Expecter) GetByProjectID(projectID interface{}) *ProjectAssetRepository_GetByProjectID_Call

+ type ProjectAssetRepository_GetByProjectID_Call struct

+ func (_c *ProjectAssetRepository_GetByProjectID_Call) Return(_a0 []models.Asset, _a1 error) *ProjectAssetRepository_GetByProjectID_Call

+ func (_c *ProjectAssetRepository_GetByProjectID_Call) Run(run func(projectID uuid.UUID)) *ProjectAssetRepository_GetByProjectID_Call

+ func (_c *ProjectAssetRepository_GetByProjectID_Call) RunAndReturn(run func(uuid.UUID) ([]models.Asset, error)) *ProjectAssetRepository_GetByProjectID_Call

+ type ProjectProjectRepository struct

+ func NewProjectProjectRepository(t interface{ ... }) *ProjectProjectRepository

+ func (_m *ProjectProjectRepository) Begin() *gorm.DB

+ func (_m *ProjectProjectRepository) Create(tx *gorm.DB, t *models.Project) error

+ func (_m *ProjectProjectRepository) CreateBatch(tx *gorm.DB, ts []models.Project) error

+ func (_m *ProjectProjectRepository) Delete(tx *gorm.DB, id uuid.UUID) error

+ func (_m *ProjectProjectRepository) EXPECT() *ProjectProjectRepository_Expecter

+ func (_m *ProjectProjectRepository) GetDB(tx *gorm.DB) *gorm.DB

+ func (_m *ProjectProjectRepository) List(ids []uuid.UUID) ([]models.Project, error)

+ func (_m *ProjectProjectRepository) Read(id uuid.UUID) (models.Project, error)

+ func (_m *ProjectProjectRepository) ReadBySlug(organizationID uuid.UUID, slug string) (models.Project, error)

+ func (_m *ProjectProjectRepository) Save(tx *gorm.DB, t *models.Project) error

+ func (_m *ProjectProjectRepository) SaveBatch(tx *gorm.DB, ts []models.Project) error

+ func (_m *ProjectProjectRepository) Transaction(_a0 func(*gorm.DB) error) error

+ type ProjectProjectRepository_Begin_Call struct

+ func (_c *ProjectProjectRepository_Begin_Call) Return(_a0 *gorm.DB) *ProjectProjectRepository_Begin_Call

+ func (_c *ProjectProjectRepository_Begin_Call) Run(run func()) *ProjectProjectRepository_Begin_Call

+ func (_c *ProjectProjectRepository_Begin_Call) RunAndReturn(run func() *gorm.DB) *ProjectProjectRepository_Begin_Call

+ type ProjectProjectRepository_CreateBatch_Call struct

+ func (_c *ProjectProjectRepository_CreateBatch_Call) Return(_a0 error) *ProjectProjectRepository_CreateBatch_Call

+ func (_c *ProjectProjectRepository_CreateBatch_Call) Run(run func(tx *gorm.DB, ts []models.Project)) *ProjectProjectRepository_CreateBatch_Call

+ func (_c *ProjectProjectRepository_CreateBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Project) error) *ProjectProjectRepository_CreateBatch_Call

+ type ProjectProjectRepository_Create_Call struct

+ func (_c *ProjectProjectRepository_Create_Call) Return(_a0 error) *ProjectProjectRepository_Create_Call

+ func (_c *ProjectProjectRepository_Create_Call) Run(run func(tx *gorm.DB, t *models.Project)) *ProjectProjectRepository_Create_Call

+ func (_c *ProjectProjectRepository_Create_Call) RunAndReturn(run func(*gorm.DB, *models.Project) error) *ProjectProjectRepository_Create_Call

+ type ProjectProjectRepository_Delete_Call struct

+ func (_c *ProjectProjectRepository_Delete_Call) Return(_a0 error) *ProjectProjectRepository_Delete_Call

+ func (_c *ProjectProjectRepository_Delete_Call) Run(run func(tx *gorm.DB, id uuid.UUID)) *ProjectProjectRepository_Delete_Call

+ func (_c *ProjectProjectRepository_Delete_Call) RunAndReturn(run func(*gorm.DB, uuid.UUID) error) *ProjectProjectRepository_Delete_Call

+ type ProjectProjectRepository_Expecter struct

+ func (_e *ProjectProjectRepository_Expecter) Begin() *ProjectProjectRepository_Begin_Call

+ func (_e *ProjectProjectRepository_Expecter) Create(tx interface{}, t interface{}) *ProjectProjectRepository_Create_Call

+ func (_e *ProjectProjectRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *ProjectProjectRepository_CreateBatch_Call

+ func (_e *ProjectProjectRepository_Expecter) Delete(tx interface{}, id interface{}) *ProjectProjectRepository_Delete_Call

+ func (_e *ProjectProjectRepository_Expecter) GetDB(tx interface{}) *ProjectProjectRepository_GetDB_Call

+ func (_e *ProjectProjectRepository_Expecter) List(ids interface{}) *ProjectProjectRepository_List_Call

+ func (_e *ProjectProjectRepository_Expecter) Read(id interface{}) *ProjectProjectRepository_Read_Call

+ func (_e *ProjectProjectRepository_Expecter) ReadBySlug(organizationID interface{}, slug interface{}) *ProjectProjectRepository_ReadBySlug_Call

+ func (_e *ProjectProjectRepository_Expecter) Save(tx interface{}, t interface{}) *ProjectProjectRepository_Save_Call

+ func (_e *ProjectProjectRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *ProjectProjectRepository_SaveBatch_Call

+ func (_e *ProjectProjectRepository_Expecter) Transaction(_a0 interface{}) *ProjectProjectRepository_Transaction_Call

+ type ProjectProjectRepository_GetDB_Call struct

+ func (_c *ProjectProjectRepository_GetDB_Call) Return(_a0 *gorm.DB) *ProjectProjectRepository_GetDB_Call

+ func (_c *ProjectProjectRepository_GetDB_Call) Run(run func(tx *gorm.DB)) *ProjectProjectRepository_GetDB_Call

+ func (_c *ProjectProjectRepository_GetDB_Call) RunAndReturn(run func(*gorm.DB) *gorm.DB) *ProjectProjectRepository_GetDB_Call

+ type ProjectProjectRepository_List_Call struct

+ func (_c *ProjectProjectRepository_List_Call) Return(_a0 []models.Project, _a1 error) *ProjectProjectRepository_List_Call

+ func (_c *ProjectProjectRepository_List_Call) Run(run func(ids []uuid.UUID)) *ProjectProjectRepository_List_Call

+ func (_c *ProjectProjectRepository_List_Call) RunAndReturn(run func([]uuid.UUID) ([]models.Project, error)) *ProjectProjectRepository_List_Call

+ type ProjectProjectRepository_ReadBySlug_Call struct

+ func (_c *ProjectProjectRepository_ReadBySlug_Call) Return(_a0 models.Project, _a1 error) *ProjectProjectRepository_ReadBySlug_Call

+ func (_c *ProjectProjectRepository_ReadBySlug_Call) Run(run func(organizationID uuid.UUID, slug string)) *ProjectProjectRepository_ReadBySlug_Call

+ func (_c *ProjectProjectRepository_ReadBySlug_Call) RunAndReturn(run func(uuid.UUID, string) (models.Project, error)) *ProjectProjectRepository_ReadBySlug_Call

+ type ProjectProjectRepository_Read_Call struct

+ func (_c *ProjectProjectRepository_Read_Call) Return(_a0 models.Project, _a1 error) *ProjectProjectRepository_Read_Call

+ func (_c *ProjectProjectRepository_Read_Call) Run(run func(id uuid.UUID)) *ProjectProjectRepository_Read_Call

+ func (_c *ProjectProjectRepository_Read_Call) RunAndReturn(run func(uuid.UUID) (models.Project, error)) *ProjectProjectRepository_Read_Call

+ type ProjectProjectRepository_SaveBatch_Call struct

+ func (_c *ProjectProjectRepository_SaveBatch_Call) Return(_a0 error) *ProjectProjectRepository_SaveBatch_Call

+ func (_c *ProjectProjectRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, ts []models.Project)) *ProjectProjectRepository_SaveBatch_Call

+ func (_c *ProjectProjectRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Project) error) *ProjectProjectRepository_SaveBatch_Call

+ type ProjectProjectRepository_Save_Call struct

+ func (_c *ProjectProjectRepository_Save_Call) Return(_a0 error) *ProjectProjectRepository_Save_Call

+ func (_c *ProjectProjectRepository_Save_Call) Run(run func(tx *gorm.DB, t *models.Project)) *ProjectProjectRepository_Save_Call

+ func (_c *ProjectProjectRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.Project) error) *ProjectProjectRepository_Save_Call

+ type ProjectProjectRepository_Transaction_Call struct

+ func (_c *ProjectProjectRepository_Transaction_Call) Return(_a0 error) *ProjectProjectRepository_Transaction_Call

+ func (_c *ProjectProjectRepository_Transaction_Call) Run(run func(_a0 func(*gorm.DB) error)) *ProjectProjectRepository_Transaction_Call

+ func (_c *ProjectProjectRepository_Transaction_Call) RunAndReturn(run func(func(*gorm.DB) error) error) *ProjectProjectRepository_Transaction_Call

+ type RiskCvssInterface struct

+ func NewRiskCvssInterface(t interface{ ... }) *RiskCvssInterface

+ func (_m *RiskCvssInterface) EXPECT() *RiskCvssInterface_Expecter

+ func (_m *RiskCvssInterface) EnvironmentalScore() float64

+ func (_m *RiskCvssInterface) Get(key string) (string, error)

+ func (_m *RiskCvssInterface) Set(key string, value string) error

+ func (_m *RiskCvssInterface) TemporalScore() float64

+ func (_m *RiskCvssInterface) Vector() string

+ type RiskCvssInterface_EnvironmentalScore_Call struct

+ func (_c *RiskCvssInterface_EnvironmentalScore_Call) Return(_a0 float64) *RiskCvssInterface_EnvironmentalScore_Call

+ func (_c *RiskCvssInterface_EnvironmentalScore_Call) Run(run func()) *RiskCvssInterface_EnvironmentalScore_Call

+ func (_c *RiskCvssInterface_EnvironmentalScore_Call) RunAndReturn(run func() float64) *RiskCvssInterface_EnvironmentalScore_Call

+ type RiskCvssInterface_Expecter struct

+ func (_e *RiskCvssInterface_Expecter) EnvironmentalScore() *RiskCvssInterface_EnvironmentalScore_Call

+ func (_e *RiskCvssInterface_Expecter) Get(key interface{}) *RiskCvssInterface_Get_Call

+ func (_e *RiskCvssInterface_Expecter) Set(key interface{}, value interface{}) *RiskCvssInterface_Set_Call

+ func (_e *RiskCvssInterface_Expecter) TemporalScore() *RiskCvssInterface_TemporalScore_Call

+ func (_e *RiskCvssInterface_Expecter) Vector() *RiskCvssInterface_Vector_Call

+ type RiskCvssInterface_Get_Call struct

+ func (_c *RiskCvssInterface_Get_Call) Return(_a0 string, _a1 error) *RiskCvssInterface_Get_Call

+ func (_c *RiskCvssInterface_Get_Call) Run(run func(key string)) *RiskCvssInterface_Get_Call

+ func (_c *RiskCvssInterface_Get_Call) RunAndReturn(run func(string) (string, error)) *RiskCvssInterface_Get_Call

+ type RiskCvssInterface_Set_Call struct

+ func (_c *RiskCvssInterface_Set_Call) Return(_a0 error) *RiskCvssInterface_Set_Call

+ func (_c *RiskCvssInterface_Set_Call) Run(run func(key string, value string)) *RiskCvssInterface_Set_Call

+ func (_c *RiskCvssInterface_Set_Call) RunAndReturn(run func(string, string) error) *RiskCvssInterface_Set_Call

+ type RiskCvssInterface_TemporalScore_Call struct

+ func (_c *RiskCvssInterface_TemporalScore_Call) Return(_a0 float64) *RiskCvssInterface_TemporalScore_Call

+ func (_c *RiskCvssInterface_TemporalScore_Call) Run(run func()) *RiskCvssInterface_TemporalScore_Call

+ func (_c *RiskCvssInterface_TemporalScore_Call) RunAndReturn(run func() float64) *RiskCvssInterface_TemporalScore_Call

+ type RiskCvssInterface_Vector_Call struct

+ func (_c *RiskCvssInterface_Vector_Call) Return(_a0 string) *RiskCvssInterface_Vector_Call

+ func (_c *RiskCvssInterface_Vector_Call) Run(run func()) *RiskCvssInterface_Vector_Call

+ func (_c *RiskCvssInterface_Vector_Call) RunAndReturn(run func() string) *RiskCvssInterface_Vector_Call

+ type ScanAssetService struct

+ func NewScanAssetService(t interface{ ... }) *ScanAssetService

+ func (_m *ScanAssetService) EXPECT() *ScanAssetService_Expecter

+ func (_m *ScanAssetService) HandleScanResult(user string, scannerID string, asset models.Asset, flaws []models.Flaw) (int, int, error)

+ func (_m *ScanAssetService) UpdateSBOM(asset models.Asset, version string, sbom *cyclonedx.BOM) error

+ type ScanAssetService_Expecter struct

+ func (_e *ScanAssetService_Expecter) HandleScanResult(user interface{}, scannerID interface{}, asset interface{}, flaws interface{}) *ScanAssetService_HandleScanResult_Call

+ func (_e *ScanAssetService_Expecter) UpdateSBOM(asset interface{}, version interface{}, sbom interface{}) *ScanAssetService_UpdateSBOM_Call

+ type ScanAssetService_HandleScanResult_Call struct

+ func (_c *ScanAssetService_HandleScanResult_Call) Return(amountOpened int, amountClosed int, err error) *ScanAssetService_HandleScanResult_Call

+ func (_c *ScanAssetService_HandleScanResult_Call) Run(...) *ScanAssetService_HandleScanResult_Call

+ func (_c *ScanAssetService_HandleScanResult_Call) RunAndReturn(run func(string, string, models.Asset, []models.Flaw) (int, int, error)) *ScanAssetService_HandleScanResult_Call

+ type ScanAssetService_UpdateSBOM_Call struct

+ func (_c *ScanAssetService_UpdateSBOM_Call) Return(_a0 error) *ScanAssetService_UpdateSBOM_Call

+ func (_c *ScanAssetService_UpdateSBOM_Call) Run(run func(asset models.Asset, version string, sbom *cyclonedx.BOM)) *ScanAssetService_UpdateSBOM_Call

+ func (_c *ScanAssetService_UpdateSBOM_Call) RunAndReturn(run func(models.Asset, string, *cyclonedx.BOM) error) *ScanAssetService_UpdateSBOM_Call

+ type ScanComparer struct

+ func NewScanComparer(t interface{ ... }) *ScanComparer

+ func (_m *ScanComparer) EXPECT() *ScanComparer_Expecter

+ func (_m *ScanComparer) GetVulns(packageIdentifier string) ([]models.VulnInPackage, error)

+ type ScanComparer_Expecter struct

+ func (_e *ScanComparer_Expecter) GetVulns(packageIdentifier interface{}) *ScanComparer_GetVulns_Call

+ type ScanComparer_GetVulns_Call struct

+ func (_c *ScanComparer_GetVulns_Call) Return(_a0 []models.VulnInPackage, _a1 error) *ScanComparer_GetVulns_Call

+ func (_c *ScanComparer_GetVulns_Call) Run(run func(packageIdentifier string)) *ScanComparer_GetVulns_Call

+ func (_c *ScanComparer_GetVulns_Call) RunAndReturn(run func(string) ([]models.VulnInPackage, error)) *ScanComparer_GetVulns_Call

+ type ScanComponentRepository struct

+ func NewScanComponentRepository(t interface{ ... }) *ScanComponentRepository

+ func (_m *ScanComponentRepository) EXPECT() *ScanComponentRepository_Expecter

+ func (_m *ScanComponentRepository) SaveBatch(tx *gorm.DB, components []models.Component) error

+ type ScanComponentRepository_Expecter struct

+ func (_e *ScanComponentRepository_Expecter) SaveBatch(tx interface{}, components interface{}) *ScanComponentRepository_SaveBatch_Call

+ type ScanComponentRepository_SaveBatch_Call struct

+ func (_c *ScanComponentRepository_SaveBatch_Call) Return(_a0 error) *ScanComponentRepository_SaveBatch_Call

+ func (_c *ScanComponentRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, components []models.Component)) *ScanComponentRepository_SaveBatch_Call

+ func (_c *ScanComponentRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Component) error) *ScanComponentRepository_SaveBatch_Call

+ type ScanCveRepository struct

+ func NewScanCveRepository(t interface{ ... }) *ScanCveRepository

+ func (_m *ScanCveRepository) EXPECT() *ScanCveRepository_Expecter

+ func (_m *ScanCveRepository) FindAll(cveIDs []string) ([]models.CVE, error)

+ type ScanCveRepository_Expecter struct

+ func (_e *ScanCveRepository_Expecter) FindAll(cveIDs interface{}) *ScanCveRepository_FindAll_Call

+ type ScanCveRepository_FindAll_Call struct

+ func (_c *ScanCveRepository_FindAll_Call) Return(_a0 []models.CVE, _a1 error) *ScanCveRepository_FindAll_Call

+ func (_c *ScanCveRepository_FindAll_Call) Run(run func(cveIDs []string)) *ScanCveRepository_FindAll_Call

+ func (_c *ScanCveRepository_FindAll_Call) RunAndReturn(run func([]string) ([]models.CVE, error)) *ScanCveRepository_FindAll_Call

+ type VulndbAffectedCmpRepository struct

+ func NewVulndbAffectedCmpRepository(t interface{ ... }) *VulndbAffectedCmpRepository

+ func (_m *VulndbAffectedCmpRepository) EXPECT() *VulndbAffectedCmpRepository_Expecter

+ func (_m *VulndbAffectedCmpRepository) SaveBatch(tx *gorm.DB, affectedComponents []models.AffectedComponent) error

+ type VulndbAffectedCmpRepository_Expecter struct

+ func (_e *VulndbAffectedCmpRepository_Expecter) SaveBatch(tx interface{}, affectedComponents interface{}) *VulndbAffectedCmpRepository_SaveBatch_Call

+ type VulndbAffectedCmpRepository_SaveBatch_Call struct

+ func (_c *VulndbAffectedCmpRepository_SaveBatch_Call) Return(_a0 error) *VulndbAffectedCmpRepository_SaveBatch_Call

+ func (_c *VulndbAffectedCmpRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, affectedComponents []models.AffectedComponent)) *VulndbAffectedCmpRepository_SaveBatch_Call

+ func (_c *VulndbAffectedCmpRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.AffectedComponent) error) *VulndbAffectedCmpRepository_SaveBatch_Call

+ type VulndbConfigService struct

+ func NewVulndbConfigService(t interface{ ... }) *VulndbConfigService

+ func (_m *VulndbConfigService) EXPECT() *VulndbConfigService_Expecter

+ func (_m *VulndbConfigService) GetJSONConfig(key string, v interface{}) error

+ func (_m *VulndbConfigService) SetJSONConfig(key string, v interface{}) error

+ type VulndbConfigService_Expecter struct

+ func (_e *VulndbConfigService_Expecter) GetJSONConfig(key interface{}, v interface{}) *VulndbConfigService_GetJSONConfig_Call

+ func (_e *VulndbConfigService_Expecter) SetJSONConfig(key interface{}, v interface{}) *VulndbConfigService_SetJSONConfig_Call

+ type VulndbConfigService_GetJSONConfig_Call struct

+ func (_c *VulndbConfigService_GetJSONConfig_Call) Return(_a0 error) *VulndbConfigService_GetJSONConfig_Call

+ func (_c *VulndbConfigService_GetJSONConfig_Call) Run(run func(key string, v interface{})) *VulndbConfigService_GetJSONConfig_Call

+ func (_c *VulndbConfigService_GetJSONConfig_Call) RunAndReturn(run func(string, interface{}) error) *VulndbConfigService_GetJSONConfig_Call

+ type VulndbConfigService_SetJSONConfig_Call struct

+ func (_c *VulndbConfigService_SetJSONConfig_Call) Return(_a0 error) *VulndbConfigService_SetJSONConfig_Call

+ func (_c *VulndbConfigService_SetJSONConfig_Call) Run(run func(key string, v interface{})) *VulndbConfigService_SetJSONConfig_Call

+ func (_c *VulndbConfigService_SetJSONConfig_Call) RunAndReturn(run func(string, interface{}) error) *VulndbConfigService_SetJSONConfig_Call

+ type VulndbCveRepository struct

+ func NewVulndbCveRepository(t interface{ ... }) *VulndbCveRepository

+ func (_m *VulndbCveRepository) Begin() *gorm.DB

+ func (_m *VulndbCveRepository) Create(tx *gorm.DB, t *models.CVE) error

+ func (_m *VulndbCveRepository) CreateBatch(tx *gorm.DB, ts []models.CVE) error

+ func (_m *VulndbCveRepository) Delete(tx *gorm.DB, id string) error

+ func (_m *VulndbCveRepository) EXPECT() *VulndbCveRepository_Expecter

+ func (_m *VulndbCveRepository) FindByID(id string) (models.CVE, error)

+ func (_m *VulndbCveRepository) GetDB(tx *gorm.DB) *gorm.DB

+ func (_m *VulndbCveRepository) GetLastModDate() (time.Time, error)

+ func (_m *VulndbCveRepository) List(ids []string) ([]models.CVE, error)

+ func (_m *VulndbCveRepository) Read(id string) (models.CVE, error)

+ func (_m *VulndbCveRepository) Save(tx *gorm.DB, t *models.CVE) error

+ func (_m *VulndbCveRepository) SaveBatch(tx *gorm.DB, ts []models.CVE) error

+ func (_m *VulndbCveRepository) Transaction(_a0 func(*gorm.DB) error) error

+ type VulndbCveRepository_Begin_Call struct

+ func (_c *VulndbCveRepository_Begin_Call) Return(_a0 *gorm.DB) *VulndbCveRepository_Begin_Call

+ func (_c *VulndbCveRepository_Begin_Call) Run(run func()) *VulndbCveRepository_Begin_Call

+ func (_c *VulndbCveRepository_Begin_Call) RunAndReturn(run func() *gorm.DB) *VulndbCveRepository_Begin_Call

+ type VulndbCveRepository_CreateBatch_Call struct

+ func (_c *VulndbCveRepository_CreateBatch_Call) Return(_a0 error) *VulndbCveRepository_CreateBatch_Call

+ func (_c *VulndbCveRepository_CreateBatch_Call) Run(run func(tx *gorm.DB, ts []models.CVE)) *VulndbCveRepository_CreateBatch_Call

+ func (_c *VulndbCveRepository_CreateBatch_Call) RunAndReturn(run func(*gorm.DB, []models.CVE) error) *VulndbCveRepository_CreateBatch_Call

+ type VulndbCveRepository_Create_Call struct

+ func (_c *VulndbCveRepository_Create_Call) Return(_a0 error) *VulndbCveRepository_Create_Call

+ func (_c *VulndbCveRepository_Create_Call) Run(run func(tx *gorm.DB, t *models.CVE)) *VulndbCveRepository_Create_Call

+ func (_c *VulndbCveRepository_Create_Call) RunAndReturn(run func(*gorm.DB, *models.CVE) error) *VulndbCveRepository_Create_Call

+ type VulndbCveRepository_Delete_Call struct

+ func (_c *VulndbCveRepository_Delete_Call) Return(_a0 error) *VulndbCveRepository_Delete_Call

+ func (_c *VulndbCveRepository_Delete_Call) Run(run func(tx *gorm.DB, id string)) *VulndbCveRepository_Delete_Call

+ func (_c *VulndbCveRepository_Delete_Call) RunAndReturn(run func(*gorm.DB, string) error) *VulndbCveRepository_Delete_Call

+ type VulndbCveRepository_Expecter struct

+ func (_e *VulndbCveRepository_Expecter) Begin() *VulndbCveRepository_Begin_Call

+ func (_e *VulndbCveRepository_Expecter) Create(tx interface{}, t interface{}) *VulndbCveRepository_Create_Call

+ func (_e *VulndbCveRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *VulndbCveRepository_CreateBatch_Call

+ func (_e *VulndbCveRepository_Expecter) Delete(tx interface{}, id interface{}) *VulndbCveRepository_Delete_Call

+ func (_e *VulndbCveRepository_Expecter) FindByID(id interface{}) *VulndbCveRepository_FindByID_Call

+ func (_e *VulndbCveRepository_Expecter) GetDB(tx interface{}) *VulndbCveRepository_GetDB_Call

+ func (_e *VulndbCveRepository_Expecter) GetLastModDate() *VulndbCveRepository_GetLastModDate_Call

+ func (_e *VulndbCveRepository_Expecter) List(ids interface{}) *VulndbCveRepository_List_Call

+ func (_e *VulndbCveRepository_Expecter) Read(id interface{}) *VulndbCveRepository_Read_Call

+ func (_e *VulndbCveRepository_Expecter) Save(tx interface{}, t interface{}) *VulndbCveRepository_Save_Call

+ func (_e *VulndbCveRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *VulndbCveRepository_SaveBatch_Call

+ func (_e *VulndbCveRepository_Expecter) Transaction(_a0 interface{}) *VulndbCveRepository_Transaction_Call

+ type VulndbCveRepository_FindByID_Call struct

+ func (_c *VulndbCveRepository_FindByID_Call) Return(_a0 models.CVE, _a1 error) *VulndbCveRepository_FindByID_Call

+ func (_c *VulndbCveRepository_FindByID_Call) Run(run func(id string)) *VulndbCveRepository_FindByID_Call

+ func (_c *VulndbCveRepository_FindByID_Call) RunAndReturn(run func(string) (models.CVE, error)) *VulndbCveRepository_FindByID_Call

+ type VulndbCveRepository_GetDB_Call struct

+ func (_c *VulndbCveRepository_GetDB_Call) Return(_a0 *gorm.DB) *VulndbCveRepository_GetDB_Call

+ func (_c *VulndbCveRepository_GetDB_Call) Run(run func(tx *gorm.DB)) *VulndbCveRepository_GetDB_Call

+ func (_c *VulndbCveRepository_GetDB_Call) RunAndReturn(run func(*gorm.DB) *gorm.DB) *VulndbCveRepository_GetDB_Call

+ type VulndbCveRepository_GetLastModDate_Call struct

+ func (_c *VulndbCveRepository_GetLastModDate_Call) Return(_a0 time.Time, _a1 error) *VulndbCveRepository_GetLastModDate_Call

+ func (_c *VulndbCveRepository_GetLastModDate_Call) Run(run func()) *VulndbCveRepository_GetLastModDate_Call

+ func (_c *VulndbCveRepository_GetLastModDate_Call) RunAndReturn(run func() (time.Time, error)) *VulndbCveRepository_GetLastModDate_Call

+ type VulndbCveRepository_List_Call struct

+ func (_c *VulndbCveRepository_List_Call) Return(_a0 []models.CVE, _a1 error) *VulndbCveRepository_List_Call

+ func (_c *VulndbCveRepository_List_Call) Run(run func(ids []string)) *VulndbCveRepository_List_Call

+ func (_c *VulndbCveRepository_List_Call) RunAndReturn(run func([]string) ([]models.CVE, error)) *VulndbCveRepository_List_Call

+ type VulndbCveRepository_Read_Call struct

+ func (_c *VulndbCveRepository_Read_Call) Return(_a0 models.CVE, _a1 error) *VulndbCveRepository_Read_Call

+ func (_c *VulndbCveRepository_Read_Call) Run(run func(id string)) *VulndbCveRepository_Read_Call

+ func (_c *VulndbCveRepository_Read_Call) RunAndReturn(run func(string) (models.CVE, error)) *VulndbCveRepository_Read_Call

+ type VulndbCveRepository_SaveBatch_Call struct

+ func (_c *VulndbCveRepository_SaveBatch_Call) Return(_a0 error) *VulndbCveRepository_SaveBatch_Call

+ func (_c *VulndbCveRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, ts []models.CVE)) *VulndbCveRepository_SaveBatch_Call

+ func (_c *VulndbCveRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.CVE) error) *VulndbCveRepository_SaveBatch_Call

+ type VulndbCveRepository_Save_Call struct

+ func (_c *VulndbCveRepository_Save_Call) Return(_a0 error) *VulndbCveRepository_Save_Call

+ func (_c *VulndbCveRepository_Save_Call) Run(run func(tx *gorm.DB, t *models.CVE)) *VulndbCveRepository_Save_Call

+ func (_c *VulndbCveRepository_Save_Call) RunAndReturn(run func(*gorm.DB, *models.CVE) error) *VulndbCveRepository_Save_Call

+ type VulndbCveRepository_Transaction_Call struct

+ func (_c *VulndbCveRepository_Transaction_Call) Return(_a0 error) *VulndbCveRepository_Transaction_Call

+ func (_c *VulndbCveRepository_Transaction_Call) Run(run func(_a0 func(*gorm.DB) error)) *VulndbCveRepository_Transaction_Call

+ func (_c *VulndbCveRepository_Transaction_Call) RunAndReturn(run func(func(*gorm.DB) error) error) *VulndbCveRepository_Transaction_Call

+ type VulndbCweRepository struct

+ func NewVulndbCweRepository(t interface{ ... }) *VulndbCweRepository

+ func (_m *VulndbCweRepository) EXPECT() *VulndbCweRepository_Expecter

+ func (_m *VulndbCweRepository) SaveBatch(tx *gorm.DB, cwes []models.CWE) error

+ type VulndbCweRepository_Expecter struct

+ func (_e *VulndbCweRepository_Expecter) SaveBatch(tx interface{}, cwes interface{}) *VulndbCweRepository_SaveBatch_Call

+ type VulndbCweRepository_SaveBatch_Call struct

+ func (_c *VulndbCweRepository_SaveBatch_Call) Return(_a0 error) *VulndbCweRepository_SaveBatch_Call

+ func (_c *VulndbCweRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, cwes []models.CWE)) *VulndbCweRepository_SaveBatch_Call

+ func (_c *VulndbCweRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.CWE) error) *VulndbCweRepository_SaveBatch_Call

+ type VulndbExploitRepository struct

+ func NewVulndbExploitRepository(t interface{ ... }) *VulndbExploitRepository

+ func (_m *VulndbExploitRepository) EXPECT() *VulndbExploitRepository_Expecter

+ func (_m *VulndbExploitRepository) SaveBatch(tx *gorm.DB, exploits []models.Exploit) error

+ type VulndbExploitRepository_Expecter struct

+ func (_e *VulndbExploitRepository_Expecter) SaveBatch(tx interface{}, exploits interface{}) *VulndbExploitRepository_SaveBatch_Call

+ type VulndbExploitRepository_SaveBatch_Call struct

+ func (_c *VulndbExploitRepository_SaveBatch_Call) Return(_a0 error) *VulndbExploitRepository_SaveBatch_Call

+ func (_c *VulndbExploitRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, exploits []models.Exploit)) *VulndbExploitRepository_SaveBatch_Call

+ func (_c *VulndbExploitRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Exploit) error) *VulndbExploitRepository_SaveBatch_Call

+ type VulndbFlawService struct

+ func NewVulndbFlawService(t interface{ ... }) *VulndbFlawService

+ func (_m *VulndbFlawService) EXPECT() *VulndbFlawService_Expecter

+ func (_m *VulndbFlawService) RecalculateAllRawRiskAssessments() error

+ type VulndbFlawService_Expecter struct

+ func (_e *VulndbFlawService_Expecter) RecalculateAllRawRiskAssessments() *VulndbFlawService_RecalculateAllRawRiskAssessments_Call

+ type VulndbFlawService_RecalculateAllRawRiskAssessments_Call struct

+ func (_c *VulndbFlawService_RecalculateAllRawRiskAssessments_Call) Return(_a0 error) *VulndbFlawService_RecalculateAllRawRiskAssessments_Call

+ func (_c *VulndbFlawService_RecalculateAllRawRiskAssessments_Call) Run(run func()) *VulndbFlawService_RecalculateAllRawRiskAssessments_Call

+ func (_c *VulndbFlawService_RecalculateAllRawRiskAssessments_Call) RunAndReturn(run func() error) *VulndbFlawService_RecalculateAllRawRiskAssessments_Call

+ type VulndbGithubExploitRepository struct

+ func NewVulndbGithubExploitRepository(t interface{ ... }) *VulndbGithubExploitRepository

+ func (_m *VulndbGithubExploitRepository) EXPECT() *VulndbGithubExploitRepository_Expecter

+ func (_m *VulndbGithubExploitRepository) SaveBatch(tx *gorm.DB, exploits []models.Exploit) error

+ type VulndbGithubExploitRepository_Expecter struct

+ func (_e *VulndbGithubExploitRepository_Expecter) SaveBatch(tx interface{}, exploits interface{}) *VulndbGithubExploitRepository_SaveBatch_Call

+ type VulndbGithubExploitRepository_SaveBatch_Call struct

+ func (_c *VulndbGithubExploitRepository_SaveBatch_Call) Return(_a0 error) *VulndbGithubExploitRepository_SaveBatch_Call

+ func (_c *VulndbGithubExploitRepository_SaveBatch_Call) Run(run func(tx *gorm.DB, exploits []models.Exploit)) *VulndbGithubExploitRepository_SaveBatch_Call

+ func (_c *VulndbGithubExploitRepository_SaveBatch_Call) RunAndReturn(run func(*gorm.DB, []models.Exploit) error) *VulndbGithubExploitRepository_SaveBatch_Call

+ type VulndbLeaderElector struct

+ func NewVulndbLeaderElector(t interface{ ... }) *VulndbLeaderElector

+ func (_m *VulndbLeaderElector) EXPECT() *VulndbLeaderElector_Expecter

+ func (_m *VulndbLeaderElector) IsLeader() bool

+ type VulndbLeaderElector_Expecter struct

+ func (_e *VulndbLeaderElector_Expecter) IsLeader() *VulndbLeaderElector_IsLeader_Call

+ type VulndbLeaderElector_IsLeader_Call struct

+ func (_c *VulndbLeaderElector_IsLeader_Call) Return(_a0 bool) *VulndbLeaderElector_IsLeader_Call

+ func (_c *VulndbLeaderElector_IsLeader_Call) Run(run func()) *VulndbLeaderElector_IsLeader_Call

+ func (_c *VulndbLeaderElector_IsLeader_Call) RunAndReturn(run func() bool) *VulndbLeaderElector_IsLeader_Call

+ type VulndbRepository struct

+ func NewVulndbRepository(t interface{ ... }) *VulndbRepository

+ func (_m *VulndbRepository) EXPECT() *VulndbRepository_Expecter

+ func (_m *VulndbRepository) FindAllListPaged(tx *gorm.DB, pageInfo core.PageInfo, filter []core.FilterQuery, ...) (core.Paged[models.CVE], error)

+ func (_m *VulndbRepository) FindCVE(tx *gorm.DB, cveId string) (interface{}, error)

+ type VulndbRepository_Expecter struct

+ func (_e *VulndbRepository_Expecter) FindAllListPaged(tx interface{}, pageInfo interface{}, filter interface{}, sort interface{}) *VulndbRepository_FindAllListPaged_Call

+ func (_e *VulndbRepository_Expecter) FindCVE(tx interface{}, cveId interface{}) *VulndbRepository_FindCVE_Call

+ type VulndbRepository_FindAllListPaged_Call struct

+ func (_c *VulndbRepository_FindAllListPaged_Call) Return(_a0 core.Paged[models.CVE], _a1 error) *VulndbRepository_FindAllListPaged_Call

+ func (_c *VulndbRepository_FindAllListPaged_Call) Run(run func(tx *gorm.DB, pageInfo core.PageInfo, filter []core.FilterQuery, ...)) *VulndbRepository_FindAllListPaged_Call

+ func (_c *VulndbRepository_FindAllListPaged_Call) RunAndReturn(...) *VulndbRepository_FindAllListPaged_Call

+ type VulndbRepository_FindCVE_Call struct

+ func (_c *VulndbRepository_FindCVE_Call) Return(_a0 interface{}, _a1 error) *VulndbRepository_FindCVE_Call

+ func (_c *VulndbRepository_FindCVE_Call) Run(run func(tx *gorm.DB, cveId string)) *VulndbRepository_FindCVE_Call

+ func (_c *VulndbRepository_FindCVE_Call) RunAndReturn(run func(*gorm.DB, string) (interface{}, error)) *VulndbRepository_FindCVE_Call

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL