diff --git a/.env.example b/.env.example index 91b9652f4..8f71d43fb 100644 --- a/.env.example +++ b/.env.example @@ -16,6 +16,8 @@ INSTANCE_DOMAIN=https://api.main.devguard.org #Choose which version of devguar FRONTEND_URL=http://localhost:3000 +OSI_LICENSES_API=https://opensource.org/api/license/ + PDF_GENERATION_API=https://dwt-api.dev-l3montree.cloud/pdf # comment to disable error tracking ERROR_TRACKING_DSN="https://" diff --git a/cmd/devguard-cli/commands/components.go b/cmd/devguard-cli/commands/components.go index aad1ad7cb..77265cf7b 100644 --- a/cmd/devguard-cli/commands/components.go +++ b/cmd/devguard-cli/commands/components.go @@ -5,6 +5,7 @@ import ( "github.com/l3montree-dev/devguard/internal/core" "github.com/l3montree-dev/devguard/internal/core/component" + "github.com/l3montree-dev/devguard/internal/core/vuln" "github.com/l3montree-dev/devguard/internal/core/vulndb" "github.com/l3montree-dev/devguard/internal/database/models" "github.com/l3montree-dev/devguard/internal/database/repositories" @@ -37,6 +38,7 @@ func newUpdateDepsDevInformation() *cobra.Command { depsDevService := vulndb.NewDepsDevService() componentProjectRepository := repositories.NewComponentProjectRepository(database) componentRepository := repositories.NewComponentRepository(database) + licenseRiskService := vuln.NewLicenseRiskService(repositories.NewLicenseRiskRepository(database), repositories.NewVulnEventRepository(database)) components, err := componentRepository.All() if err != nil { @@ -48,6 +50,7 @@ func newUpdateDepsDevInformation() *cobra.Command { &depsDevService, componentProjectRepository, componentRepository, + licenseRiskService, ) bar := progressbar.Default(int64(len(components))) diff --git a/cmd/devguard/api/api.go b/cmd/devguard/api/api.go index 242a05209..10eef2014 100644 --- a/cmd/devguard/api/api.go +++ b/cmd/devguard/api/api.go @@ -398,7 +398,7 @@ func BuildRouter(db core.DB) *echo.Echo { supplyChainRepository := repositories.NewSupplyChainRepository(db) attestationRepository := repositories.NewAttestationRepository(db) policyRepository := repositories.NewPolicyRepository(db) - licenseOverwriteRepository := repositories.NewLicenseOverwriteRepository(db) + licenseRiskRepository := repositories.NewLicenseRiskRepository(db) dependencyVulnService := vuln.NewService(dependencyVulnRepository, vulnEventRepository, assetRepository, cveRepository, orgRepository, projectRepository, thirdPartyIntegration, assetVersionRepository) firstPartyVulnService := vuln.NewFirstPartyVulnService(firstPartyVulnRepository, vulnEventRepository, assetRepository) @@ -410,7 +410,8 @@ func BuildRouter(db core.DB) *echo.Echo { assetService := asset.NewService(assetRepository, dependencyVulnRepository, dependencyVulnService) depsDevService := vulndb.NewDepsDevService() componentProjectRepository := repositories.NewComponentProjectRepository(db) - componentService := component.NewComponentService(&depsDevService, componentProjectRepository, componentRepository) + licenseRiskService := vuln.NewLicenseRiskService(licenseRiskRepository, vulnEventRepository) + componentService := component.NewComponentService(&depsDevService, componentProjectRepository, componentRepository, licenseRiskService) assetVersionService := assetversion.NewService(assetVersionRepository, componentRepository, dependencyVulnRepository, firstPartyVulnRepository, dependencyVulnService, firstPartyVulnService, assetRepository, vulnEventRepository, &componentService) statisticsService := statistics.NewService(statisticsRepository, componentRepository, assetRiskAggregationRepository, dependencyVulnRepository, assetVersionRepository, projectRepository, repositories.NewProjectRiskHistoryRepository(db)) @@ -429,15 +430,16 @@ func BuildRouter(db core.DB) *echo.Echo { scanController := scan.NewHTTPController(db, cveRepository, componentRepository, assetRepository, assetVersionRepository, assetVersionService, statisticsService, dependencyVulnService) - assetVersionController := assetversion.NewAssetVersionController(assetVersionRepository, assetVersionService, dependencyVulnRepository, componentRepository, dependencyVulnService, supplyChainRepository, licenseOverwriteRepository) + assetVersionController := assetversion.NewAssetVersionController(assetVersionRepository, assetVersionService, dependencyVulnRepository, componentRepository, dependencyVulnService, supplyChainRepository, licenseRiskRepository) attestationController := attestation.NewAttestationController(attestationRepository, assetVersionRepository) intotoController := intoto.NewHTTPController(intotoLinkRepository, supplyChainRepository, assetVersionRepository, patRepository, intotoService) - componentController := component.NewHTTPController(componentRepository, assetVersionRepository, licenseOverwriteRepository) + componentController := component.NewHTTPController(componentRepository, assetVersionRepository, licenseRiskRepository) + complianceController := compliance.NewHTTPController(assetVersionRepository, attestationRepository, policyRepository) statisticsController := statistics.NewHTTPController(statisticsService, statisticsRepository, assetRepository, assetVersionRepository, projectService) firstPartyVulnController := vuln.NewFirstPartyVulnController(firstPartyVulnRepository, firstPartyVulnService, projectService) - licenseOverwriteController := component.NewLicenseOverwriteController(licenseOverwriteRepository) + licenseRiskController := vuln.NewLicenseRiskController(licenseRiskRepository, licenseRiskService) patService := pat.NewPatService(patRepository) @@ -555,8 +557,6 @@ func BuildRouter(db core.DB) *echo.Echo { organizationRouter.POST("/projects/", projectController.Create, neededScope([]string{"manage"}), accessControlMiddleware(core.ObjectOrganization, core.ActionUpdate)) organizationRouter.GET("/config-files/:config-file/", orgController.GetConfigFile) - organizationRouter.PUT("/license-overwrite/", licenseOverwriteController.Create, neededScope([]string{"manage"})) - organizationRouter.DELETE("/license-overwrite/:componentPurl", licenseOverwriteController.Delete, neededScope([]string{"manage"})) //Api functions for interacting with a project inside an organization -> .../organizations//projects//... projectRouter := organizationRouter.Group("/projects/:projectSlug", projectAccessControl(projectService, "project", core.ActionRead)) projectRouter.GET("/", projectController.Read) @@ -673,10 +673,8 @@ func BuildRouter(db core.DB) *echo.Echo { dependencyVulnRouter := assetVersionRouter.Group("/dependency-vulns") dependencyVulnRouter.GET("/", dependencyVulnController.ListPaged) dependencyVulnRouter.GET("/:dependencyVulnID/", dependencyVulnController.Read) - dependencyVulnRouter.POST("/:dependencyVulnID/", dependencyVulnController.CreateEvent, neededScope([]string{"manage"}), projectScopedRBAC(core.ObjectAsset, core.ActionUpdate)) dependencyVulnRouter.POST("/:dependencyVulnID/mitigate/", dependencyVulnController.Mitigate, neededScope([]string{"manage"}), projectScopedRBAC(core.ObjectAsset, core.ActionUpdate)) - dependencyVulnRouter.GET("/:dependencyVulnID/events/", vulnEventController.ReadAssetEventsByVulnID) firstPartyVulnRouter := assetVersionRouter.Group("/first-party-vulns") @@ -686,6 +684,14 @@ func BuildRouter(db core.DB) *echo.Echo { firstPartyVulnRouter.POST("/:firstPartyVulnID/mitigate/", firstPartyVulnController.Mitigate, neededScope([]string{"manage"}), projectScopedRBAC(core.ObjectAsset, core.ActionUpdate)) firstPartyVulnRouter.GET("/:firstPartyVulnID/events/", vulnEventController.ReadAssetEventsByVulnID) + assetVersionRouter.POST("/license-risks/", licenseRiskController.Create) + licenseRiskRouter := assetVersionRouter.Group("/license-risks") + licenseRiskRouter.GET("/", licenseRiskController.ListPaged) + licenseRiskRouter.GET("/:licenseRiskID/", licenseRiskController.Read) + licenseRiskRouter.POST("/:licenseRiskID/", licenseRiskController.CreateEvent, neededScope([]string{"manage"}), projectScopedRBAC(core.ObjectAsset, core.ActionUpdate)) + licenseRiskRouter.POST("/:licenseRiskID/mitigate", licenseRiskController.Mitigate, neededScope([]string{"manage"}), projectScopedRBAC(core.ObjectAsset, core.ActionUpdate)) + licenseRiskRouter.POST("/:licenseRiskID/final-license-decision", licenseRiskController.MakeFinalLicenseDecision, neededScope([]string{"manage"}), projectScopedRBAC(core.ObjectAsset, core.ActionUpdate)) + routes := server.Routes() sort.Slice(routes, func(i, j int) bool { return routes[i].Path < routes[j].Path diff --git a/internal/core/assetversion/asset_version_controller.go b/internal/core/assetversion/asset_version_controller.go index 43bb342b5..1e98f0bd7 100644 --- a/internal/core/assetversion/asset_version_controller.go +++ b/internal/core/assetversion/asset_version_controller.go @@ -26,13 +26,13 @@ import ( ) type AssetVersionController struct { - assetVersionRepository core.AssetVersionRepository - assetVersionService core.AssetVersionService - dependencyVulnRepository core.DependencyVulnRepository - componentRepository core.ComponentRepository - dependencyVulnService core.DependencyVulnService - supplyChainRepository core.SupplyChainRepository - licenseOverwriteRepository core.LicenseOverwriteRepository + assetVersionRepository core.AssetVersionRepository + assetVersionService core.AssetVersionService + dependencyVulnRepository core.DependencyVulnRepository + componentRepository core.ComponentRepository + dependencyVulnService core.DependencyVulnService + supplyChainRepository core.SupplyChainRepository + licenseRiskRepository core.LicenseRiskRepository } func NewAssetVersionController( @@ -42,16 +42,16 @@ func NewAssetVersionController( componentRepository core.ComponentRepository, dependencyVulnService core.DependencyVulnService, supplyChainRepository core.SupplyChainRepository, - licenseOverwriteRepository core.LicenseOverwriteRepository, + licenseRiskRepository core.LicenseRiskRepository, ) *AssetVersionController { return &AssetVersionController{ - assetVersionRepository: assetVersionRepository, - assetVersionService: assetVersionService, - dependencyVulnRepository: dependencyVulnRepository, - componentRepository: componentRepository, - dependencyVulnService: dependencyVulnService, - supplyChainRepository: supplyChainRepository, - licenseOverwriteRepository: licenseOverwriteRepository, + assetVersionRepository: assetVersionRepository, + assetVersionService: assetVersionService, + dependencyVulnRepository: dependencyVulnRepository, + componentRepository: componentRepository, + dependencyVulnService: dependencyVulnService, + supplyChainRepository: supplyChainRepository, + licenseRiskRepository: licenseRiskRepository, } } @@ -218,7 +218,7 @@ func (a *AssetVersionController) buildSBOM(ctx core.Context) (*cdx.BOM, error) { scannerID := ctx.QueryParam("scanner") - overwrittenLicenses, err := a.licenseOverwriteRepository.GetAllOverwritesForOrganization(org.ID) + overwrittenLicenses, err := a.licenseRiskRepository.GetAllOverwrittenLicensesForAssetVersion(assetVersion.AssetID, assetVersion.Name) if err != nil { return nil, err } diff --git a/internal/core/assetversion/asset_version_service.go b/internal/core/assetversion/asset_version_service.go index 20b2d3a55..5cc3164c9 100644 --- a/internal/core/assetversion/asset_version_service.go +++ b/internal/core/assetversion/asset_version_service.go @@ -427,8 +427,8 @@ func (s *service) UpdateSBOM(assetVersion models.AssetVersion, scannerID string, } existingComponentPurls := make(map[string]bool) - for _, c := range assetComponents { - existingComponentPurls[c.Component.Purl] = true + for _, currentComponent := range assetComponents { + existingComponentPurls[currentComponent.Component.Purl] = true } // we need to check if the SBOM is new or if it already exists. @@ -524,7 +524,7 @@ func (s *service) UpdateSBOM(assetVersion models.AssetVersion, scannerID string, go func() { slog.Info("updating license information in background", "asset", assetVersion.Name, "assetID", assetVersion.AssetID) - _, err := s.componentService.GetAndSaveLicenseInformation(assetVersion.Name, assetVersion.AssetID, scannerID) + _, err := s.componentService.GetAndSaveLicenseInformation(assetVersion, scannerID) if err != nil { slog.Error("could not update license information", "asset", assetVersion.Name, "assetID", assetVersion.AssetID, "err", err) } else { @@ -576,6 +576,7 @@ func (s *service) BuildSBOM(assetVersion models.AssetVersion, version string, or licenses := cdx.Licenses{} //technically redundant call to c.Dependency.ComponentProject.License if c.Dependency.ComponentProject != nil && c.Dependency.ComponentProject.License != "" { + // if the license is not a valid osi license we need to assign that to the name attribute in the license choice struct, because ID can only contain valid IDs if c.Dependency.ComponentProject.License != "non-standard" { licenses = append(licenses, cdx.LicenseChoice{ License: &cdx.License{ diff --git a/internal/core/common_interfaces.go b/internal/core/common_interfaces.go index a4444f95f..d9ec15f22 100644 --- a/internal/core/common_interfaces.go +++ b/internal/core/common_interfaces.go @@ -123,7 +123,7 @@ type ComponentRepository interface { common.Repository[string, models.Component, DB] LoadComponents(tx DB, assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.ComponentDependency, error) - LoadComponentsWithProject(tx DB, overwrittenLicenses []models.LicenseOverwrite, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo PageInfo, search string, filter []FilterQuery, sort []SortQuery) (Paged[models.ComponentDependency], error) + LoadComponentsWithProject(tx DB, overwrittenLicenses []models.LicenseRisk, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo PageInfo, search string, filter []FilterQuery, sort []SortQuery) (Paged[models.ComponentDependency], error) LoadPathToComponent(tx DB, assetVersionName string, assetID uuid.UUID, pURL string, scannerID string) ([]models.ComponentDependency, error) SaveBatch(tx DB, components []models.Component) error FindByPurl(tx DB, purl string) (models.Component, error) @@ -164,6 +164,17 @@ type FirstPartyVulnRepository interface { GetByAssetVersion(tx DB, assetVersionName string, assetID uuid.UUID) ([]models.FirstPartyVuln, error) } +type LicenseRiskRepository interface { + common.Repository[string, models.LicenseRisk, DB] + GetAllLicenseRisksForAssetVersionPaged(tx DB, assetID uuid.UUID, assetVersionName string, pageInfo PageInfo, search string, filter []FilterQuery, sort []SortQuery) (Paged[models.LicenseRisk], error) + GetAllLicenseRisksForAssetVersion(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error) + GetAllOverwrittenLicensesForAssetVersion(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error) + MaybeGetLicenseOverwriteForComponent(assetID uuid.UUID, assetVersionName string, pURL packageurl.PackageURL) (models.LicenseRisk, error) + DeleteByComponentPurl(assetID uuid.UUID, assetVersionName string, purl packageurl.PackageURL) error + ListByScanner(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.LicenseRisk, error) + ApplyAndSave(tx DB, licenseRisk *models.LicenseRisk, vulnEvent *models.VulnEvent) error +} + type InTotoLinkRepository interface { common.Repository[uuid.UUID, models.InTotoLink, DB] FindByAssetAndSupplyChainID(assetID uuid.UUID, supplyChainID string) ([]models.InTotoLink, error) @@ -304,13 +315,6 @@ type VulnRepository interface { ApplyAndSave(tx DB, dependencyVuln models.Vuln, vulnEvent *models.VulnEvent) error } -type LicenseOverwriteRepository interface { - common.Repository[string, models.LicenseOverwrite, DB] - GetAllOverwritesForOrganization(orgID uuid.UUID) ([]models.LicenseOverwrite, error) - MaybeGetOverwriteForComponent(orgID uuid.UUID, pURL packageurl.PackageURL) (models.LicenseOverwrite, error) - DeleteByComponentPurlAndOrgID(orgID uuid.UUID, purl string) error -} - type ExternalUserRepository interface { Save(db DB, user *models.ExternalUser) error GetDB(tx DB) DB @@ -381,11 +385,17 @@ type ComponentProjectRepository interface { } type ComponentService interface { - GetAndSaveLicenseInformation(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.Component, error) + GetAndSaveLicenseInformation(assetVersion models.AssetVersion, scannerID string) ([]models.Component, error) RefreshComponentProjectInformation(project models.ComponentProject) GetLicense(component models.Component) (models.Component, error) } +type LicenseRiskService interface { + FindLicenseRisksInComponents(assetVersion models.AssetVersion, components []models.Component, scannerID string) error + UpdateLicenseRiskState(tx DB, userID string, licenseRisk *models.LicenseRisk, statusType string, justification string, mechanicalJustification models.MechanicalJustificationType) (models.VulnEvent, error) + MakeFinalLicenseDecision(vulnID string, finalLicense string, userID string) error +} + type AccessControl interface { HasAccess(subject string) (bool, error) // return error if couldnt be checked due to unauthorized access or other issues diff --git a/internal/core/component/component_controller.go b/internal/core/component/component_controller.go index 5bd2d4af8..a94be60b3 100644 --- a/internal/core/component/component_controller.go +++ b/internal/core/component/component_controller.go @@ -5,16 +5,16 @@ import ( ) type httpController struct { - componentRepository core.ComponentRepository - assetVersionRepository core.AssetVersionRepository - licenseOverwriteRepository core.LicenseOverwriteRepository + componentRepository core.ComponentRepository + assetVersionRepository core.AssetVersionRepository + licenseRiskRepository core.LicenseRiskRepository } -func NewHTTPController(componentRepository core.ComponentRepository, assetVersionRepository core.AssetVersionRepository, licenseOverwriteRepository core.LicenseOverwriteRepository) *httpController { +func NewHTTPController(componentRepository core.ComponentRepository, assetVersionRepository core.AssetVersionRepository, licenseOverwriteRepository core.LicenseRiskRepository) *httpController { return &httpController{ - componentRepository: componentRepository, - assetVersionRepository: assetVersionRepository, - licenseOverwriteRepository: licenseOverwriteRepository, + componentRepository: componentRepository, + assetVersionRepository: assetVersionRepository, + licenseRiskRepository: licenseOverwriteRepository, } } @@ -74,9 +74,7 @@ func (httpController httpController) ListPaged(ctx core.Context) error { search := ctx.QueryParam("search") sort := core.GetSortQuery(ctx) - orgID := core.GetOrg(ctx).ID - - overwrittenLicense, err := httpController.licenseOverwriteRepository.GetAllOverwritesForOrganization(orgID) + overwrittenLicense, err := httpController.licenseRiskRepository.GetAllOverwrittenLicensesForAssetVersion(assetVersion.AssetID, assetVersion.Name) if err != nil { return err } diff --git a/internal/core/component/component_service.go b/internal/core/component/component_service.go index 4bc12aa81..c0aab02e4 100644 --- a/internal/core/component/component_service.go +++ b/internal/core/component/component_service.go @@ -4,7 +4,6 @@ import ( "context" "log/slog" - "github.com/google/uuid" "github.com/l3montree-dev/devguard/internal/core" "github.com/l3montree-dev/devguard/internal/database" "github.com/l3montree-dev/devguard/internal/database/models" @@ -17,13 +16,15 @@ type service struct { componentRepository core.ComponentRepository depsDevService core.DepsDevService componentProjectRepository core.ComponentProjectRepository + licenseRiskService core.LicenseRiskService } -func NewComponentService(depsDevService core.DepsDevService, componentProjectRepository core.ComponentProjectRepository, componentRepository core.ComponentRepository) service { +func NewComponentService(depsDevService core.DepsDevService, componentProjectRepository core.ComponentProjectRepository, componentRepository core.ComponentRepository, licenseRiskService core.LicenseRiskService) service { return service{ componentRepository: componentRepository, componentProjectRepository: componentProjectRepository, depsDevService: depsDevService, + licenseRiskService: licenseRiskService, } } @@ -151,8 +152,8 @@ func (s *service) GetLicense(component models.Component) (models.Component, erro return component, nil } -func (s *service) GetAndSaveLicenseInformation(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.Component, error) { - componentDependencies, err := s.componentRepository.LoadComponents(nil, assetVersionName, assetID, scannerID) +func (s *service) GetAndSaveLicenseInformation(assetVersion models.AssetVersion, scannerID string) ([]models.Component, error) { + componentDependencies, err := s.componentRepository.LoadComponents(nil, assetVersion.Name, assetVersion.AssetID, scannerID) if err != nil { return nil, err } @@ -167,10 +168,10 @@ func (s *service) GetAndSaveLicenseInformation(assetVersionName string, assetID } } + //why are we only getting new licenses and not updating existing ones? - licenses shouldn't change after once they are set slog.Info("getting license information for components", "amount", len(componentsWithoutLicense)) errGroup := utils.ErrGroup[models.Component](10) for _, component := range componentsWithoutLicense { - component := component errGroup.Go(func() (models.Component, error) { return s.GetLicense(component) }) @@ -187,10 +188,19 @@ func (s *service) GetAndSaveLicenseInformation(assetVersionName string, assetID return nil, err } - // now return all components - each one should have the best license information available allComponents := components + // get all the components - with licenses and without for _, componentDependency := range componentDependencies { - allComponents = append(allComponents, componentDependency.Dependency) + if !seen[componentDependency.DependencyPurl] { + // if the component is not in the seen map, it means it was not processed to get a new license + allComponents = append(allComponents, componentDependency.Dependency) + } + } + + // find potential license risks + err = s.licenseRiskService.FindLicenseRisksInComponents(assetVersion, allComponents, scannerID) + if err != nil { + return nil, err } return allComponents, nil diff --git a/internal/core/component/component_service_integration_test.go b/internal/core/component/component_service_integration_test.go new file mode 100644 index 000000000..d96ecf16e --- /dev/null +++ b/internal/core/component/component_service_integration_test.go @@ -0,0 +1,308 @@ +package component_test + +import ( + "net/http" + "net/http/httptest" + "os" + "testing" + + integration_tests "github.com/l3montree-dev/devguard/integrationtestutil" + "github.com/l3montree-dev/devguard/internal/common" + "github.com/l3montree-dev/devguard/internal/core/component" + "github.com/l3montree-dev/devguard/internal/core/vuln" + "github.com/l3montree-dev/devguard/internal/database/models" + "github.com/l3montree-dev/devguard/internal/database/repositories" + "github.com/l3montree-dev/devguard/internal/utils" + "github.com/l3montree-dev/devguard/mocks" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" +) + +// resetOSILicenseCache resets the global license cache +func resetOSILicenseCache() { + vuln.ResetOSILicenseCache() +} + +func TestGetAndSaveLicenseInformation(t *testing.T) { + // Set up a mock OSI licenses API server that returns known valid licenses + // This avoids external API dependencies in tests + mockLicenses := `[ + {"spdx_id": "MIT"}, + {"spdx_id": "Apache-2.0"}, + {"spdx_id": "GPL-3.0-only"}, + {"spdx_id": "BSD-3-Clause"} + ]` + + // Create a simple HTTP server for testing + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte(mockLicenses)) + })) + defer server.Close() + + // Set the OSI API URL to our test server + os.Setenv("OSI_LICENSES_API", server.URL) + defer os.Unsetenv("OSI_LICENSES_API") + + t.Run("should create license risk entries for components with invalid licenses", func(t *testing.T) { + // Clear the license cache to ensure we use our mock server + // This is a bit of a hack but necessary since the license cache is global + // Reset the global license cache + resetOSILicenseCache() + + // Initialize database container + db, terminate := integration_tests.InitDatabaseContainer("../../../initdb.sql") + defer terminate() + + // Auto-migrate required models + err := db.AutoMigrate( + &models.Org{}, + &models.Project{}, + &models.Asset{}, + &models.AssetVersion{}, + &models.Component{}, + &models.ComponentDependency{}, + &models.ComponentProject{}, + &models.LicenseRisk{}, + &models.VulnEvent{}, + ) + assert.NoError(t, err) + + // Create test data using the utility function + _, _, _, assetVersion := integration_tests.CreateOrgProjectAndAssetAssetVersion(db) + + // Create test components with different license scenarios + componentWithInvalidLicense := models.Component{ + Purl: "pkg:npm/test-package@1.0.0", + Version: "1.0.0", + License: utils.Ptr("PROPRIETARY"), // Invalid OSI license + } + + componentWithValidLicense := models.Component{ + Purl: "pkg:npm/valid-package@1.0.0", + Version: "1.0.0", + License: utils.Ptr("MIT"), // Valid OSI license + } + + componentWithoutLicense := models.Component{ + Purl: "pkg:npm/no-license-package@1.0.0", + Version: "1.0.0", + License: nil, // No license - will be handled by GetLicense + } + + // Save components to database + err = db.Create(&componentWithInvalidLicense).Error + assert.NoError(t, err) + err = db.Create(&componentWithValidLicense).Error + assert.NoError(t, err) + err = db.Create(&componentWithoutLicense).Error + assert.NoError(t, err) + + // Create component dependencies + scannerID := "test-scanner" + componentDeps := []models.ComponentDependency{ + { + AssetVersionName: assetVersion.Name, + AssetID: assetVersion.AssetID, + DependencyPurl: componentWithInvalidLicense.Purl, + Dependency: componentWithInvalidLicense, + ScannerIDs: scannerID, + }, + { + AssetVersionName: assetVersion.Name, + AssetID: assetVersion.AssetID, + DependencyPurl: componentWithValidLicense.Purl, + Dependency: componentWithValidLicense, + ScannerIDs: scannerID, + }, + { + AssetVersionName: assetVersion.Name, + AssetID: assetVersion.AssetID, + DependencyPurl: componentWithoutLicense.Purl, + Dependency: componentWithoutLicense, + ScannerIDs: scannerID, + }, + } + + for _, dep := range componentDeps { + err = db.Create(&dep).Error + assert.NoError(t, err) + } + + // Set up repositories + componentRepository := repositories.NewComponentRepository(db) + componentProjectRepository := repositories.NewComponentProjectRepository(db) + licenseRiskRepository := repositories.NewLicenseRiskRepository(db) + vulnEventRepository := repositories.NewVulnEventRepository(db) + + // Set up services + licenseRiskService := vuln.NewLicenseRiskService(licenseRiskRepository, vulnEventRepository) + + // Mock the DepsDevService for the component without license + mockDepsDevService := mocks.NewDepsDevService(t) + + // Mock response for the component without license - simulate getting "unknown" license + mockDepsDevService.On("GetVersion", mock.Anything, "npm", "no-license-package", "1.0.0"). + Return(common.DepsDevVersionResponse{ + Licenses: []string{}, // No licenses returned + }, nil) + + // Create the component service with mocked dependencies + componentService := component.NewComponentService( + mockDepsDevService, + componentProjectRepository, + componentRepository, + licenseRiskService, + ) + + // Call the function under test + resultComponents, err := componentService.GetAndSaveLicenseInformation(assetVersion, scannerID) + assert.NoError(t, err) + assert.NotEmpty(t, resultComponents) + + // Verify that license risks were created for components with invalid licenses + var licenseRisks []models.LicenseRisk + err = db.Where("asset_id = ? AND asset_version_name = ?", assetVersion.AssetID, assetVersion.Name).Find(&licenseRisks).Error + assert.NoError(t, err) + + // We should have license risks for: + // 1. componentWithInvalidLicense (PROPRIETARY license) + // 2. componentWithoutLicense (will get "unknown" license which is invalid) + expectedRiskCount := 2 + assert.Equal(t, expectedRiskCount, len(licenseRisks)) + + // Check specific license risk entries + licenseRiskPurls := make(map[string]models.LicenseRisk) + for _, risk := range licenseRisks { + licenseRiskPurls[risk.ComponentPurl] = risk + } + + // Verify license risk for component with invalid license + invalidLicenseRisk, exists := licenseRiskPurls[componentWithInvalidLicense.Purl] + assert.True(t, exists, "License risk should exist for component with invalid license") + assert.Equal(t, models.VulnStateOpen, invalidLicenseRisk.State) + assert.Equal(t, scannerID, invalidLicenseRisk.ScannerIDs) + assert.Equal(t, assetVersion.AssetID, invalidLicenseRisk.AssetID) + assert.Equal(t, assetVersion.Name, invalidLicenseRisk.AssetVersionName) + + // Verify license risk for component without license (should get "unknown") + unknownLicenseRisk, exists := licenseRiskPurls[componentWithoutLicense.Purl] + assert.True(t, exists, "License risk should exist for component with unknown license") + assert.Equal(t, models.VulnStateOpen, unknownLicenseRisk.State) + + // Verify NO license risk was created for component with valid license + _, exists = licenseRiskPurls[componentWithValidLicense.Purl] + assert.False(t, exists, "No license risk should exist for component with valid license") + + // Verify that corresponding vuln events were created + var vulnEvents []models.VulnEvent + err = db.Where("vuln_type = ?", models.VulnTypeLicenseRisk).Find(&vulnEvents).Error + assert.NoError(t, err) + assert.Equal(t, expectedRiskCount, len(vulnEvents)) + + // Verify vuln events are of correct type + for _, event := range vulnEvents { + assert.Equal(t, models.VulnTypeLicenseRisk, event.VulnType) + assert.Equal(t, models.EventTypeDetected, event.Type) + assert.Equal(t, "system", event.UserID) + } + + t.Logf("Successfully created %d license risks and %d vuln events", len(licenseRisks), len(vulnEvents)) + }) + + t.Run("should not create duplicate license risks for existing entries", func(t *testing.T) { + // Clear the license cache to ensure consistent test behavior + resetOSILicenseCache() + + // Initialize database container + db, terminate := integration_tests.InitDatabaseContainer("../../../initdb.sql") + defer terminate() + + // Auto-migrate required models + err := db.AutoMigrate( + &models.Org{}, + &models.Project{}, + &models.Asset{}, + &models.AssetVersion{}, + &models.Component{}, + &models.ComponentDependency{}, + &models.ComponentProject{}, + &models.LicenseRisk{}, + &models.VulnEvent{}, + ) + assert.NoError(t, err) + + // Create test data + _, _, _, assetVersion := integration_tests.CreateOrgProjectAndAssetAssetVersion(db) + + // Create component with invalid license + componentWithInvalidLicense := models.Component{ + Purl: "pkg:npm/test-package@1.0.0", + Version: "1.0.0", + License: utils.Ptr("PROPRIETARY"), + } + err = db.Create(&componentWithInvalidLicense).Error + assert.NoError(t, err) + + scannerID := "test-scanner" + + // Create component dependency + componentDep := models.ComponentDependency{ + AssetVersionName: assetVersion.Name, + AssetID: assetVersion.AssetID, + DependencyPurl: componentWithInvalidLicense.Purl, + Dependency: componentWithInvalidLicense, + ScannerIDs: scannerID, + } + err = db.Create(&componentDep).Error + assert.NoError(t, err) + + // Create existing license risk + existingLicenseRisk := models.LicenseRisk{ + Vulnerability: models.Vulnerability{ + AssetVersionName: assetVersion.Name, + AssetID: assetVersion.AssetID, + State: models.VulnStateOpen, + ScannerIDs: scannerID, + }, + ComponentPurl: componentWithInvalidLicense.Purl, + FinalLicenseDecision: "", + } + // Manually set the ID using the same calculation as the model + existingLicenseRisk.ID = existingLicenseRisk.CalculateHash() + err = db.Create(&existingLicenseRisk).Error + assert.NoError(t, err) + + // Set up repositories and services + componentRepository := repositories.NewComponentRepository(db) + componentProjectRepository := repositories.NewComponentProjectRepository(db) + licenseRiskRepository := repositories.NewLicenseRiskRepository(db) + vulnEventRepository := repositories.NewVulnEventRepository(db) + licenseRiskService := vuln.NewLicenseRiskService(licenseRiskRepository, vulnEventRepository) + + mockDepsDevService := mocks.NewDepsDevService(t) + + componentService := component.NewComponentService( + mockDepsDevService, + componentProjectRepository, + componentRepository, + licenseRiskService, + ) + + // Call the function under test + _, err = componentService.GetAndSaveLicenseInformation(assetVersion, scannerID) + assert.NoError(t, err) + + // Verify that no duplicate license risk was created + var licenseRisks []models.LicenseRisk + err = db.Where("asset_id = ? AND asset_version_name = ?", assetVersion.AssetID, assetVersion.Name).Find(&licenseRisks).Error + assert.NoError(t, err) + + // Should still have only 1 license risk (the existing one) + assert.Equal(t, 1, len(licenseRisks)) + assert.Equal(t, existingLicenseRisk.ID, licenseRisks[0].ID) + + t.Log("Successfully avoided creating duplicate license risk entries") + }) +} diff --git a/internal/core/component/component_service_test.go b/internal/core/component/component_service_test.go index 0406c4e85..4e7c38871 100644 --- a/internal/core/component/component_service_test.go +++ b/internal/core/component/component_service_test.go @@ -20,8 +20,9 @@ func TestHandleComponent(t *testing.T) { mockDepsDevService := mocks.NewDepsDevService(t) mockComponentProjectRepository := mocks.NewComponentProjectRepository(t) mockComponentRepository := mocks.NewComponentRepository(t) + mockLicenseRiskService := mocks.NewLicenseRiskService(t) - service := component.NewComponentService(mockDepsDevService, mockComponentProjectRepository, mockComponentRepository) + service := component.NewComponentService(mockDepsDevService, mockComponentProjectRepository, mockComponentRepository, mockLicenseRiskService) component := models.Component{ Purl: "pkg:golang/gorm.io/gorm@v1.25.12", @@ -41,6 +42,7 @@ func TestHandleComponent(t *testing.T) { mockDepsDevService := mocks.NewDepsDevService(t) mockComponentProjectRepository := mocks.NewComponentProjectRepository(t) mockComponentRepository := mocks.NewComponentRepository(t) + mockLicenseRiskService := mocks.NewLicenseRiskService(t) c := models.Component{ Purl: "pkg:golang/gorm.io/gorm@v1.25.12", @@ -49,7 +51,7 @@ func TestHandleComponent(t *testing.T) { } mockDepsDevService.On("GetVersion", mock.Anything, "golang", "gorm.io/gorm", "v1.25.12").Return(common.DepsDevVersionResponse{}, assert.AnError) - service := component.NewComponentService(mockDepsDevService, mockComponentProjectRepository, mockComponentRepository) + service := component.NewComponentService(mockDepsDevService, mockComponentProjectRepository, mockComponentRepository, mockLicenseRiskService) actual, err := service.GetLicense(c) @@ -62,6 +64,7 @@ func TestHandleComponent(t *testing.T) { mockDepsDevService := mocks.NewDepsDevService(t) mockComponentProjectRepository := mocks.NewComponentProjectRepository(t) mockComponentRepository := mocks.NewComponentRepository(t) + mockLicenseRiskService := mocks.NewLicenseRiskService(t) c := models.Component{ Purl: "pkg:golang/gorm.io/gorm@v1.25.12", @@ -93,7 +96,7 @@ func TestHandleComponent(t *testing.T) { } mockDepsDevService.On("GetProject", mock.Anything, "github/test/project").Return(projectResponse, nil) - service := component.NewComponentService(mockDepsDevService, mockComponentProjectRepository, mockComponentRepository) + service := component.NewComponentService(mockDepsDevService, mockComponentProjectRepository, mockComponentRepository, mockLicenseRiskService) actual, err := service.GetLicense(c) @@ -106,6 +109,7 @@ func TestHandleProject(t *testing.T) { t.Run("should save the project information", func(t *testing.T) { mockDepsDevService := mocks.NewDepsDevService(t) mockComponentProjectRepository := mocks.NewComponentProjectRepository(t) + mockLicenseRiskService := mocks.NewLicenseRiskService(t) project := models.ComponentProject{ ProjectKey: "github/test/project", @@ -151,7 +155,7 @@ func TestHandleProject(t *testing.T) { mockComponentProjectRepository.On("Save", mock.Anything, &expectedProject).Return(nil) - service := component.NewComponentService(mockDepsDevService, mockComponentProjectRepository, nil) + service := component.NewComponentService(mockDepsDevService, mockComponentProjectRepository, nil, mockLicenseRiskService) service.RefreshComponentProjectInformation(project) }) } diff --git a/internal/core/component/license_overwrite_controller.go b/internal/core/component/license_overwrite_controller.go deleted file mode 100644 index 64b537a7b..000000000 --- a/internal/core/component/license_overwrite_controller.go +++ /dev/null @@ -1,71 +0,0 @@ -package component - -import ( - "net/url" - - "github.com/google/uuid" - "github.com/l3montree-dev/devguard/internal/core" - "github.com/l3montree-dev/devguard/internal/database/models" - "github.com/labstack/echo/v4" - "github.com/package-url/packageurl-go" -) - -type LicenseOverwriteController struct { - LicenseOverwriteRepository core.LicenseOverwriteRepository -} - -func NewLicenseOverwriteController(licenseOverwriteRepository core.LicenseOverwriteRepository) *LicenseOverwriteController { - return &LicenseOverwriteController{ - LicenseOverwriteRepository: licenseOverwriteRepository, - } -} - -func (controller LicenseOverwriteController) GetComponentOverwriteForOrganization(orgID uuid.UUID, pURL string) (models.LicenseOverwrite, error) { - var result models.LicenseOverwrite - validPURL, err := packageurl.FromString(pURL) - if err != nil { - return result, err - } - result, err = controller.LicenseOverwriteRepository.MaybeGetOverwriteForComponent(orgID, validPURL) - if err != nil { - return result, err - } - return result, nil -} - -func (controller LicenseOverwriteController) Create(ctx core.Context) error { - var newLicenseOverwrite models.LicenseOverwrite - if err := ctx.Bind(&newLicenseOverwrite); err != nil { - return echo.NewHTTPError(400, "unable to process request").WithInternal(err) - } - - if err := core.V.Struct(newLicenseOverwrite); err != nil { - return echo.NewHTTPError(400, err.Error()) - } - if newLicenseOverwrite.LicenseID == "" { - return echo.NewHTTPError(400, "license id must not be empty") - } - err := controller.LicenseOverwriteRepository.Save(nil, &newLicenseOverwrite) - if err != nil { - return echo.NewHTTPError(500, err.Error()) - } - return ctx.JSON(200, newLicenseOverwrite) -} - -func (controller LicenseOverwriteController) Delete(ctx core.Context) error { - componentPurl := ctx.Param("componentPurl") - if componentPurl == "" { - return echo.NewHTTPError(400, "could not retrieve a valid license id") - } - // url decode - componentPurl, err := url.PathUnescape(componentPurl) - if err != nil { - return echo.NewHTTPError(400, "invalid component purl").WithInternal(err) - } - - err = controller.LicenseOverwriteRepository.DeleteByComponentPurlAndOrgID(core.GetOrg(ctx).ID, componentPurl) - if err != nil { - return echo.NewHTTPError(500, err.Error()) - } - return ctx.NoContent(200) -} diff --git a/internal/core/context_utils.go b/internal/core/context_utils.go index 92d901edc..fa80f6347 100644 --- a/internal/core/context_utils.go +++ b/internal/core/context_utils.go @@ -102,11 +102,11 @@ func GetVulnID(ctx Context) (string, models.VulnType, error) { if dependencyVulnID != "" { return dependencyVulnID, models.VulnTypeDependencyVuln, nil } - dependencyVulnIDFromGet, ok := ctx.Get("dependencyVulnID").(string) if ok && dependencyVulnIDFromGet != "" { return dependencyVulnIDFromGet, models.VulnTypeDependencyVuln, nil } + firstPartyVulnID := ctx.Param("firstPartyVulnID") if firstPartyVulnID != "" { return firstPartyVulnID, models.VulnTypeFirstPartyVuln, nil @@ -116,6 +116,15 @@ func GetVulnID(ctx Context) (string, models.VulnType, error) { return firstPartyVulnIDFromGet, models.VulnTypeFirstPartyVuln, nil } + licenseRiskID := ctx.Param("licenseRiskID") + if licenseRiskID != "" { + return licenseRiskID, models.VulnTypeLicenseRisk, nil + } + licenseRiskIDFromGet, ok := ctx.Get("licenseRiskID").(string) + if ok && licenseRiskIDFromGet != "" { + return licenseRiskIDFromGet, models.VulnTypeLicenseRisk, nil + } + return "", "", fmt.Errorf("could not get vuln id") } diff --git a/internal/core/daemon/deps_dev_daemon.go b/internal/core/daemon/deps_dev_daemon.go index ce2807304..60a5f30d3 100644 --- a/internal/core/daemon/deps_dev_daemon.go +++ b/internal/core/daemon/deps_dev_daemon.go @@ -5,6 +5,7 @@ import ( "github.com/l3montree-dev/devguard/internal/core" "github.com/l3montree-dev/devguard/internal/core/component" + "github.com/l3montree-dev/devguard/internal/core/vuln" "github.com/l3montree-dev/devguard/internal/core/vulndb" "github.com/l3montree-dev/devguard/internal/database/repositories" "github.com/l3montree-dev/devguard/internal/monitoring" @@ -18,7 +19,8 @@ func UpdateDepsDevInformation(db core.DB) error { componentProjectRepository := repositories.NewComponentProjectRepository(db) projectsToUpdate, err := componentProjectRepository.FindAllOutdatedProjects() depsDevService := vulndb.NewDepsDevService() - componentService := component.NewComponentService(&depsDevService, componentProjectRepository, repositories.NewComponentRepository(db)) + licenseRiskService := vuln.NewLicenseRiskService(repositories.NewLicenseRiskRepository(db), repositories.NewVulnEventRepository(db)) + componentService := component.NewComponentService(&depsDevService, componentProjectRepository, repositories.NewComponentRepository(db), licenseRiskService) if err != nil { return err diff --git a/internal/core/daemon/scan_daemon.go b/internal/core/daemon/scan_daemon.go index 9f9c3e65d..576b9cd79 100644 --- a/internal/core/daemon/scan_daemon.go +++ b/internal/core/daemon/scan_daemon.go @@ -40,6 +40,7 @@ func ScanAssetVersions(db core.DB, rbacProvider core.RBACProvider) error { statisticsRepository := repositories.NewStatisticsRepository(db) assetRiskHistoryRepository := repositories.NewAssetRiskHistoryRepository(db) projectRiskHistoryRepository := repositories.NewProjectRiskHistoryRepository(db) + licenseRiskRepository := repositories.NewLicenseRiskRepository(db) gitlabOauth2Integrations := gitlabint.NewGitLabOauth2Integrations(db) gitlabClientFactory := gitlabint.NewGitlabClientFactory( @@ -55,7 +56,8 @@ func ScanAssetVersions(db core.DB, rbacProvider core.RBACProvider) error { dependencyVulnService := vuln.NewService(dependencyVulnRepository, vulnEventRepository, assetRepository, cveRepository, orgRepository, projectRepository, thirdPartyIntegration, assetVersionRepository) firstPartyVulnService := vuln.NewFirstPartyVulnService(firstPartyVulnerabilityRepository, vulnEventRepository, assetRepository) depsDevService := vulndb.NewDepsDevService() - componentService := component.NewComponentService(&depsDevService, componentProjectRepository, componentRepository) + licenseRiskService := vuln.NewLicenseRiskService(licenseRiskRepository, vulnEventRepository) + componentService := component.NewComponentService(&depsDevService, componentProjectRepository, componentRepository, licenseRiskService) assetVersionService := assetversion.NewService(assetVersionRepository, componentRepository, dependencyVulnRepository, firstPartyVulnerabilityRepository, dependencyVulnService, firstPartyVulnService, assetRepository, vulnEventRepository, &componentService) diff --git a/internal/core/integrations/githubint/github_integration.go b/internal/core/integrations/githubint/github_integration.go index 950af36a1..df3eb4365 100644 --- a/internal/core/integrations/githubint/github_integration.go +++ b/internal/core/integrations/githubint/github_integration.go @@ -67,6 +67,7 @@ type GithubIntegration struct { assetRepository core.AssetRepository assetVersionRepository core.AssetVersionRepository componentRepository core.ComponentRepository + licenseRiskRepository core.LicenseRiskRepository orgRepository core.OrganizationRepository projectRepository core.ProjectRepository @@ -87,6 +88,7 @@ func NewGithubIntegration(db core.DB) *GithubIntegration { projectRepository := repositories.NewProjectRepository(db) orgRepository := repositories.NewOrgRepository(db) firstPartyVulnRepository := repositories.NewFirstPartyVulnerabilityRepository(db) + licenseRiskRepository := repositories.NewLicenseRiskRepository(db) frontendURL := os.Getenv("FRONTEND_URL") if frontendURL == "" { @@ -106,6 +108,7 @@ func NewGithubIntegration(db core.DB) *GithubIntegration { componentRepository: componentRepository, projectRepository: projectRepository, orgRepository: orgRepository, + licenseRiskRepository: licenseRiskRepository, githubClientFactory: func(repoID string) (githubClientFacade, error) { return NewGithubClient(installationIDFromRepositoryID(repoID)) @@ -574,6 +577,12 @@ func (githubIntegration *GithubIntegration) HandleEvent(event any) error { return err } vuln = &v + case models.VulnTypeLicenseRisk: + v, err := githubIntegration.licenseRiskRepository.Read(vulnID) + if err != nil { + return err + } + vuln = &v } orgSlug, err := core.GetOrgSlug(event.Ctx) @@ -604,6 +613,12 @@ func (githubIntegration *GithubIntegration) HandleEvent(event any) error { return err } vuln = &v + case models.VulnTypeLicenseRisk: + v, err := githubIntegration.licenseRiskRepository.Read(ev.VulnID) + if err != nil { + return err + } + vuln = &v } if vuln.GetTicketID() == nil { diff --git a/internal/core/integrations/gitlabint/gitlab_handle_event.go b/internal/core/integrations/gitlabint/gitlab_handle_event.go index 434ea8262..7448afb20 100644 --- a/internal/core/integrations/gitlabint/gitlab_handle_event.go +++ b/internal/core/integrations/gitlabint/gitlab_handle_event.go @@ -45,6 +45,12 @@ func (g *GitlabIntegration) HandleEvent(event any) error { return err } vuln = &v + case models.VulnTypeLicenseRisk: + licenseRisk, err := g.licenseRiskRepository.Read(vulnID) + if err != nil { + return err + } + vuln = &licenseRisk } orgSlug, err := core.GetOrgSlug(event.Ctx) @@ -74,6 +80,12 @@ func (g *GitlabIntegration) HandleEvent(event any) error { return err } vuln = &v + case models.VulnTypeLicenseRisk: + licenseRisk, err := g.licenseRiskRepository.Read(ev.VulnID) + if err != nil { + return err + } + vuln = &licenseRisk } asset := core.GetAsset(event.Ctx) diff --git a/internal/core/integrations/gitlabint/gitlab_integration.go b/internal/core/integrations/gitlabint/gitlab_integration.go index 1b1b411cd..1ae77de70 100644 --- a/internal/core/integrations/gitlabint/gitlab_integration.go +++ b/internal/core/integrations/gitlabint/gitlab_integration.go @@ -113,6 +113,8 @@ type GitlabIntegration struct { assetService core.AssetService componentRepository core.ComponentRepository casbinRBACProvider core.RBACProvider + licenseRiskRepository core.LicenseRiskRepository + licenseRiskService core.LicenseRiskService } var _ core.ThirdPartyIntegration = &GitlabIntegration{} @@ -133,12 +135,14 @@ func NewGitlabIntegration(db core.DB, oauth2GitlabIntegration map[string]*Gitlab componentRepository := repositories.NewComponentRepository(db) firstPartyVulnRepository := repositories.NewFirstPartyVulnerabilityRepository(db) gitlabOauth2TokenRepository := repositories.NewGitlabOauth2TokenRepository(db) + licenseRiskRepository := repositories.NewLicenseRiskRepository(db) orgRepository := repositories.NewOrgRepository(db) orgService := org.NewService(orgRepository, casbinRBACProvider) projectService := project.NewService(projectRepository, assetRepository) assetService := asset.NewService(assetRepository, dependencyVulnRepository, nil) + licenseRiskService := vuln.NewLicenseRiskService(licenseRiskRepository, vulnEventRepository) frontendURL := os.Getenv("FRONTEND_URL") if frontendURL == "" { @@ -165,6 +169,8 @@ func NewGitlabIntegration(db core.DB, oauth2GitlabIntegration map[string]*Gitlab assetService: assetService, casbinRBACProvider: casbinRBACProvider, clientFactory: clientFactory, + licenseRiskRepository: licenseRiskRepository, + licenseRiskService: licenseRiskService, } } diff --git a/internal/core/vuln/dependency_vuln_service.go b/internal/core/vuln/dependency_vuln_service.go index 702093daa..d11f9894c 100644 --- a/internal/core/vuln/dependency_vuln_service.go +++ b/internal/core/vuln/dependency_vuln_service.go @@ -296,7 +296,6 @@ func (s *service) RecalculateRawRiskAssessment(tx core.DB, userID string, depend func (s *service) UpdateDependencyVulnState(tx core.DB, assetID uuid.UUID, userID string, dependencyVuln *models.DependencyVuln, statusType string, justification string, mechanicalJustification models.MechanicalJustificationType, assetVersionName string) (models.VulnEvent, error) { if tx == nil { - var ev models.VulnEvent var err error // we are not part of a parent transaction - create a new one diff --git a/internal/core/vuln/first_party_vuln_controller.go b/internal/core/vuln/first_party_vuln_controller.go index eecf39672..dd25bbf5a 100644 --- a/internal/core/vuln/first_party_vuln_controller.go +++ b/internal/core/vuln/first_party_vuln_controller.go @@ -108,7 +108,7 @@ func (c firstPartyVulnController) Mitigate(ctx core.Context) error { // fetch the firstPartyVuln again from the database. We do not know anything what might have changed. The third party integrations might have changed the state of the vuln. firstPartyVuln, err := c.firstPartyVulnRepository.Read(firstPartyVulnID) if err != nil { - return echo.NewHTTPError(404, "could not find dependencyVuln") + return echo.NewHTTPError(404, "could not find firstPartyVuln") } return ctx.JSON(200, convertFirstPartyVulnToDetailedDTO(firstPartyVuln)) diff --git a/internal/core/vuln/first_party_vuln_dto.go b/internal/core/vuln/first_party_vuln_dto.go index b9e15a079..be0fa719f 100644 --- a/internal/core/vuln/first_party_vuln_dto.go +++ b/internal/core/vuln/first_party_vuln_dto.go @@ -11,6 +11,7 @@ type FirstPartyVulnDTO struct { ID string `json:"id"` ScannerIDs string `json:"scannerIds"` Message *string `json:"message"` + AssetVersionName string `json:"assetVersionName"` AssetID string `json:"assetId"` State models.VulnState `json:"state"` RuleID string `json:"ruleId"` @@ -47,6 +48,7 @@ func FirstPartyVulnToDto(f models.FirstPartyVuln) FirstPartyVulnDTO { ID: f.ID, ScannerIDs: f.ScannerIDs, Message: f.Message, + AssetVersionName: f.AssetVersionName, AssetID: f.AssetID.String(), State: f.State, RuleID: f.RuleID, diff --git a/internal/core/vuln/license_risk_controller.go b/internal/core/vuln/license_risk_controller.go new file mode 100644 index 000000000..84f7c0219 --- /dev/null +++ b/internal/core/vuln/license_risk_controller.go @@ -0,0 +1,240 @@ +package vuln + +import ( + "encoding/json" + "log/slog" + "net/url" + + "github.com/google/uuid" + "github.com/l3montree-dev/devguard/internal/core" + "github.com/l3montree-dev/devguard/internal/core/events" + "github.com/l3montree-dev/devguard/internal/database/models" + "github.com/l3montree-dev/devguard/internal/utils" + "github.com/labstack/echo/v4" + "github.com/package-url/packageurl-go" +) + +type LicenseRiskController struct { + licenseRiskRepository core.LicenseRiskRepository + licenseRiskService core.LicenseRiskService +} + +type LicenseRiskStatus struct { + StatusType string `json:"status"` + Justification string `json:"justification"` + MechanicalJustification models.MechanicalJustificationType `json:"mechanicalJustification"` +} + +func NewLicenseRiskController(licenseOverwriteRepository core.LicenseRiskRepository, LicenseRiskService core.LicenseRiskService) *LicenseRiskController { + return &LicenseRiskController{ + licenseRiskRepository: licenseOverwriteRepository, + licenseRiskService: LicenseRiskService, + } +} + +func (controller LicenseRiskController) ListPaged(ctx core.Context) error { + // get the asset + assetVersion := core.GetAssetVersion(ctx) + + pagedResp, err := controller.licenseRiskRepository.GetAllLicenseRisksForAssetVersionPaged( + nil, + assetVersion.AssetID, + assetVersion.Name, + core.GetPageInfo(ctx), + ctx.QueryParam("search"), + core.GetFilterQuery(ctx), + core.GetSortQuery(ctx), + ) + + if err != nil { + return echo.NewHTTPError(500, "could not get license risks").WithInternal(err) + } + + return ctx.JSON(200, pagedResp.Map(func(licenseRisk models.LicenseRisk) any { + return convertLicenseRiskToDetailedDTO(licenseRisk) + })) + +} + +func (controller LicenseRiskController) GetComponentOverwriteForAssetVersion(assetID uuid.UUID, assetVersionName string, pURL string) (models.LicenseRisk, error) { + var result models.LicenseRisk + validPURL, err := packageurl.FromString(pURL) + if err != nil { + return result, err + } + result, err = controller.licenseRiskRepository.MaybeGetLicenseOverwriteForComponent(assetID, assetVersionName, validPURL) + if err != nil { + return result, err + } + return result, nil +} + +func (controller LicenseRiskController) Create(ctx core.Context) error { + var newLicenseRisk models.LicenseRisk + if err := ctx.Bind(&newLicenseRisk); err != nil { + return echo.NewHTTPError(400, "unable to process request").WithInternal(err) + } + + if err := core.V.Struct(newLicenseRisk); err != nil { + return echo.NewHTTPError(400, err.Error()) + } + if newLicenseRisk.FinalLicenseDecision == "" { + return echo.NewHTTPError(400, "license id must not be empty") + } + err := controller.licenseRiskRepository.Save(nil, &newLicenseRisk) + if err != nil { + return echo.NewHTTPError(500, err.Error()) + } + return ctx.JSON(200, newLicenseRisk) +} + +func (controller LicenseRiskController) Delete(ctx core.Context) error { + componentPurl := ctx.Param("componentPurl") + assetVersion := core.GetAssetVersion(ctx) + if componentPurl == "" { + return echo.NewHTTPError(400, "could not retrieve a valid component purl") + } + // url decode + componentPurl, err := url.PathUnescape(componentPurl) + if err != nil { + return echo.NewHTTPError(400, "invalid component purl").WithInternal(err) + } + // validate package url + parsedPURL, err := packageurl.FromString(componentPurl) + if err != nil { + return echo.NewHTTPError(400, "invalid component purl").WithInternal(err) + } + + err = controller.licenseRiskRepository.DeleteByComponentPurl(assetVersion.AssetID, assetVersion.Name, parsedPURL) + if err != nil { + return echo.NewHTTPError(500, err.Error()) + } + return ctx.NoContent(200) +} + +func convertLicenseRiskToDetailedDTO(licenseRisk models.LicenseRisk) detailedLicenseRiskDTO { + return detailedLicenseRiskDTO{ + LicenseRiskDTO: LicenseRiskToDto(licenseRisk), + Events: utils.Map(licenseRisk.Events, func(ev models.VulnEvent) events.VulnEventDTO { + return events.VulnEventDTO{ + ID: ev.ID, + Type: ev.Type, + VulnID: ev.VulnID, + UserID: ev.UserID, + Justification: ev.Justification, + MechanicalJustification: ev.MechanicalJustification, + AssetVersionName: licenseRisk.AssetVersionName, + VulnerabilityName: licenseRisk.ComponentPurl, + ArbitraryJSONData: ev.GetArbitraryJSONData(), + CreatedAt: ev.CreatedAt, + } + }), + } +} + +func (controller LicenseRiskController) Read(ctx core.Context) error { + licenseRiskID, _, err := core.GetVulnID(ctx) + if err != nil { + return echo.NewHTTPError(400, "could not get license risk ID") + } + licenseRisk, err := controller.licenseRiskRepository.Read(licenseRiskID) + if err != nil { + return echo.NewHTTPError(404, "could fetch data from the database") + } + return ctx.JSON(200, convertLicenseRiskToDetailedDTO(licenseRisk)) +} + +func (controller LicenseRiskController) Mitigate(ctx core.Context) error { + var justification struct { + Comment string `json:"comment"` + } + + err := ctx.Bind(&justification) + if err != nil { + return echo.NewHTTPError(500, "could not bind the request to a justification") + } + + licenseRiskID, _, err := core.GetVulnID(ctx) + if err != nil { + return echo.NewHTTPError(400, "invalid licenseRisk id") + } + + thirdPartyIntegrations := core.GetThirdPartyIntegration(ctx) + + err = thirdPartyIntegrations.HandleEvent(core.ManualMitigateEvent{ + Ctx: ctx, + Justification: justification.Comment, + }) + if err != nil { + return echo.NewHTTPError(500, "could not mitigate licenseRisk").WithInternal(err) + } + + licenseRisk, err := controller.licenseRiskRepository.Read(licenseRiskID) + if err != nil { + return echo.NewHTTPError(404, "could not find licenseRisk") + } + return ctx.JSON(200, convertLicenseRiskToDetailedDTO(licenseRisk)) +} + +func (controller LicenseRiskController) CreateEvent(ctx core.Context) error { + thirdPartyIntegration := core.GetThirdPartyIntegration(ctx) + licenseRiskID, _, err := core.GetVulnID(ctx) + if err != nil { + return echo.NewHTTPError(400, "invalid licenseRisk id") + } + + licenseRisk, err := controller.licenseRiskRepository.Read(licenseRiskID) + if err != nil { + return echo.NewHTTPError(404, "could not find licenseRisk") + } + userID := core.GetSession(ctx).GetUserID() + + var status LicenseRiskStatus + err = json.NewDecoder(ctx.Request().Body).Decode(&status) + if err != nil { + return echo.NewHTTPError(400, "invalid payload").WithInternal(err) + } + + statusType := status.StatusType + err = models.CheckStatusType(statusType) + if err != nil { + return echo.NewHTTPError(400, "invalid status type") + } + justification := status.Justification + mechanicalJustification := status.MechanicalJustification + + event, err := controller.licenseRiskService.UpdateLicenseRiskState(nil, userID, &licenseRisk, statusType, justification, mechanicalJustification) + if err != nil { + return err + } + err = thirdPartyIntegration.HandleEvent(core.VulnEvent{ + Ctx: ctx, + Event: event, + }) + // we do not want the transaction to be rolled back if the third party integration fails + if err != nil { + // just log the error + slog.Error("could not handle event", "err", err) + return echo.NewHTTPError(500, "could not create licenseRisk event").WithInternal(err) + } + return ctx.JSON(200, convertLicenseRiskToDetailedDTO(licenseRisk)) +} + +func (controller LicenseRiskController) MakeFinalLicenseDecision(ctx core.Context) error { + var licenseDecision struct { + License string `json:"license"` + } + + err := ctx.Bind(&licenseDecision) + if err != nil { + return echo.NewHTTPError(500, "could not bind the request to a licenseDecision") + } + + vulnID, vulnType, err := core.GetVulnID(ctx) + if err != nil || vulnType != models.VulnTypeLicenseRisk { + return echo.NewHTTPError(500, "could not get vulnID") + } + + userID := core.GetSession(ctx).GetUserID() + return controller.licenseRiskService.MakeFinalLicenseDecision(vulnID, licenseDecision.License, userID) +} diff --git a/internal/core/vuln/license_risk_dto.go b/internal/core/vuln/license_risk_dto.go new file mode 100644 index 000000000..dab45db74 --- /dev/null +++ b/internal/core/vuln/license_risk_dto.go @@ -0,0 +1,48 @@ +package vuln + +import ( + "time" + + "github.com/l3montree-dev/devguard/internal/core/events" + "github.com/l3montree-dev/devguard/internal/database/models" +) + +type LicenseRiskDTO struct { + ID string `json:"id"` + ScannerIDs string `json:"scannerIds"` + Message *string `json:"message"` + AssetVersionName string `json:"assetVersionName"` + AssetID string `json:"assetId"` + State models.VulnState `json:"state"` + CreatedAt time.Time `json:"createdAt"` + TicketID *string `json:"ticketId"` + TicketURL *string `json:"ticketUrl"` + ManualTicketCreation bool `json:"manualTicketCreation"` + + FinalLicenseDecision string `json:"finalLicenseDecision"` + ComponentPurl string `json:"componentPurl"` +} + +type detailedLicenseRiskDTO struct { + LicenseRiskDTO + Events []events.VulnEventDTO `json:"events"` +} + +func LicenseRiskToDto(f models.LicenseRisk) LicenseRiskDTO { + + return LicenseRiskDTO{ + ID: f.ID, + ScannerIDs: f.ScannerIDs, + Message: f.Message, + AssetVersionName: f.AssetVersionName, + AssetID: f.AssetID.String(), + State: f.State, + CreatedAt: f.CreatedAt, + TicketID: f.TicketID, + TicketURL: f.TicketURL, + ManualTicketCreation: f.ManualTicketCreation, + + FinalLicenseDecision: f.FinalLicenseDecision, + ComponentPurl: f.ComponentPurl, + } +} diff --git a/internal/core/vuln/license_risk_service.go b/internal/core/vuln/license_risk_service.go new file mode 100644 index 000000000..ca9208129 --- /dev/null +++ b/internal/core/vuln/license_risk_service.go @@ -0,0 +1,180 @@ +package vuln + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "net/http" + "os" + "time" + + "github.com/l3montree-dev/devguard/internal/common" + "github.com/l3montree-dev/devguard/internal/core" + "github.com/l3montree-dev/devguard/internal/database/models" +) + +type LicenseRiskService struct { + licenseRiskRepository core.LicenseRiskRepository + vulnEventRepository core.VulnEventRepository +} + +func NewLicenseRiskService(licenseRiskRepository core.LicenseRiskRepository, vulnEventRepository core.VulnEventRepository) *LicenseRiskService { + return &LicenseRiskService{ + licenseRiskRepository: licenseRiskRepository, + vulnEventRepository: vulnEventRepository, + } +} + +func (service *LicenseRiskService) FindLicenseRisksInComponents(assetVersion models.AssetVersion, components []models.Component, scannerID string) error { + existingLicenseRisks, err := service.licenseRiskRepository.ListByScanner(assetVersion.Name, assetVersion.AssetID, scannerID) + if err != nil { + return err + } + // put all the license risks we already have into a hash map for faster look up times + doesLicenseRiskAlreadyExist := make(map[string]struct{}) + for i := range existingLicenseRisks { + doesLicenseRiskAlreadyExist[existingLicenseRisks[i].ComponentPurl] = struct{}{} + } + + // get all current valid licenses to compare against + licenseMap, err := GetOSILicenses() + if err != nil { + return err + } + + //collect all risks before saving to the database, should be more efficient + allLicenseRisks := []models.LicenseRisk{} + allVulnEvents := []models.VulnEvent{} + //go over every component and check if the license is a valid osi license; if not we can create a license risk with the provided information + for _, component := range components { + _, validLicense := licenseMap[*component.License] + _, exists := doesLicenseRiskAlreadyExist[component.Purl] + // if we have an invalid license and we don not have a risk for this we create one + if !validLicense && !exists { + licenseRisk := models.LicenseRisk{ + Vulnerability: models.Vulnerability{ + AssetVersionName: assetVersion.Name, + AssetID: assetVersion.AssetID, + AssetVersion: assetVersion, + State: models.VulnStateOpen, + ScannerIDs: scannerID, + LastDetected: time.Now(), + }, + FinalLicenseDecision: "", + ComponentPurl: component.Purl, + } + allLicenseRisks = append(allLicenseRisks, licenseRisk) + ev := models.NewDetectedEvent(licenseRisk.CalculateHash(), models.VulnTypeLicenseRisk, "system", common.RiskCalculationReport{}, scannerID) + // apply the event on the dependencyVuln + ev.Apply(&licenseRisk) + allVulnEvents = append(allVulnEvents, ev) + } + } + err = service.licenseRiskRepository.SaveBatch(nil, allLicenseRisks) + if err != nil { + return err + } + err = service.vulnEventRepository.SaveBatch(nil, allVulnEvents) + if err != nil { + return err + } + return nil +} + +var validOSILicenseMap map[string]struct{} = make(map[string]struct{}) // cache for valid OSI licenses + +// ResetOSILicenseCache clears the cached OSI licenses for testing purposes +func ResetOSILicenseCache() { + validOSILicenseMap = make(map[string]struct{}) +} + +func GetOSILicenses() (map[string]struct{}, error) { + if len(validOSILicenseMap) > 0 { + return validOSILicenseMap, nil + } + + apiURL := os.Getenv("OSI_LICENSES_API") + if apiURL == "" { + return nil, fmt.Errorf("could not get the URL of the OSI API, check the OSI_LICENSES_API variable in your .env file") + } + + req, err := http.NewRequest("GET", apiURL, nil) + if err != nil { + return nil, fmt.Errorf("could not build the http request: %s", err) + } + client := http.DefaultClient + client.Timeout = time.Minute + + resp, err := client.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + if resp.StatusCode != 200 { + return nil, fmt.Errorf("http request to %s was unsuccessful (code: %d)", apiURL, resp.StatusCode) + } + response := bytes.Buffer{} + type osiLicense struct { + ID string `json:"spdx_id"` + } + var licenses []osiLicense + _, err = io.Copy(&response, resp.Body) + if err != nil { + return nil, err + } + err = json.Unmarshal(response.Bytes(), &licenses) + if err != nil { + return nil, err + } + + for _, license := range licenses { + if license.ID != "" { + validOSILicenseMap[license.ID] = struct{}{} + } + } + return validOSILicenseMap, nil +} + +func (service *LicenseRiskService) UpdateLicenseRiskState(tx core.DB, userID string, licenseRisk *models.LicenseRisk, statusType string, justification string, mechanicalJustification models.MechanicalJustificationType) (models.VulnEvent, error) { + if tx == nil { + var ev models.VulnEvent + var err error + // we are not part of a parent transaction - create a new one + err = service.licenseRiskRepository.Transaction(func(d core.DB) error { + ev, err = service.updateLicenseRiskState(tx, userID, licenseRisk, statusType, justification, mechanicalJustification) + return err + }) + return ev, err + } + return service.updateLicenseRiskState(tx, userID, licenseRisk, statusType, justification, mechanicalJustification) +} + +func (service *LicenseRiskService) updateLicenseRiskState(tx core.DB, userID string, licenseRisk *models.LicenseRisk, statusType string, justification string, mechanicalJustification models.MechanicalJustificationType) (models.VulnEvent, error) { + var ev models.VulnEvent + switch models.VulnEventType(statusType) { + case models.EventTypeAccepted: + ev = models.NewAcceptedEvent(licenseRisk.CalculateHash(), models.VulnTypeLicenseRisk, userID, justification) + case models.EventTypeFalsePositive: + ev = models.NewFalsePositiveEvent(licenseRisk.CalculateHash(), models.VulnTypeLicenseRisk, userID, justification, mechanicalJustification, licenseRisk.ScannerIDs) + case models.EventTypeReopened: + ev = models.NewReopenedEvent(licenseRisk.CalculateHash(), models.VulnTypeLicenseRisk, userID, justification) + case models.EventTypeComment: + ev = models.NewCommentEvent(licenseRisk.CalculateHash(), models.VulnTypeLicenseRisk, userID, justification) + } + + err := service.licenseRiskRepository.ApplyAndSave(tx, licenseRisk, &ev) + return ev, err +} + +func (service *LicenseRiskService) MakeFinalLicenseDecision(vulnID, finalLicense, userID string) error { + licenseRisk, err := service.licenseRiskRepository.Read(vulnID) + if err != nil { + return err + } + licenseRisk.State = models.VulnStateFixed + licenseRisk.FinalLicenseDecision = finalLicense + + ev := models.NewFixedEvent(vulnID, models.VulnTypeLicenseRisk, userID, licenseRisk.ScannerIDs) + return service.licenseRiskRepository.ApplyAndSave(nil, &licenseRisk, &ev) +} diff --git a/internal/core/vulndb/scan/scan_integration_test.go b/internal/core/vulndb/scan/scan_integration_test.go index c47742ca8..1bb85c819 100644 --- a/internal/core/vulndb/scan/scan_integration_test.go +++ b/internal/core/vulndb/scan/scan_integration_test.go @@ -29,6 +29,7 @@ func TestScanning(t *testing.T) { defer terminate() os.Setenv("FRONTEND_URL", "FRONTEND_URL") + os.Setenv("OSI_LICENSES_API", "https://opensource.org/api/license/") controller, _ := initHTTPController(t, db) // scan the vulnerable sbom @@ -232,6 +233,7 @@ func TestTicketHandling(t *testing.T) { defer terminate() os.Setenv("FRONTEND_URL", "FRONTEND_URL") + os.Setenv("OSI_LICENSES_API", "https://opensource.org/api/license/") controller, gitlabClientFacade := initHTTPController(t, db) // scan the vulnerable sbom diff --git a/internal/database/models/license_overwrite_model.go b/internal/database/models/license_overwrite_model.go deleted file mode 100644 index fde91910e..000000000 --- a/internal/database/models/license_overwrite_model.go +++ /dev/null @@ -1,14 +0,0 @@ -package models - -import "github.com/google/uuid" - -type LicenseOverwrite struct { - LicenseID string `json:"licenseId" gorm:"type:text"` - OrganizationID uuid.UUID `json:"organizationId" gorm:"type:uuid;foreignKey:OrganizationID;references:ID;OnDelete:CASCADE;primarykey"` - ComponentPurl string `json:"componentPurl" gorm:"type:text;primarykey"` - Justification string `json:"justification" gorm:"type:text"` -} - -func (m LicenseOverwrite) TableName() string { - return "license_overwrite" -} diff --git a/internal/database/models/license_risk_model.go b/internal/database/models/license_risk_model.go new file mode 100644 index 000000000..be49c991d --- /dev/null +++ b/internal/database/models/license_risk_model.go @@ -0,0 +1,34 @@ +package models + +import ( + "fmt" + + "github.com/l3montree-dev/devguard/internal/utils" + "gorm.io/gorm" +) + +type LicenseRisk struct { + Vulnerability + FinalLicenseDecision string `json:"finalLicenseDecision" gorm:"type:text"` + ComponentPurl string `json:"componentPurl" gorm:"type:text;primarykey"` +} + +func (licenseRisk LicenseRisk) TableName() string { + return "license_risks" +} + +func (licenseRisk LicenseRisk) GetType() VulnType { + return VulnTypeLicenseRisk +} + +func (licenseRisk *LicenseRisk) CalculateHash() string { + // we should only use static and unique information for the hash ( maybe we need to add scanner IDs, see pull request) + hash := utils.HashString(fmt.Sprintf("%s/%s/%s", licenseRisk.ComponentPurl, licenseRisk.AssetVersionName, licenseRisk.AssetID)) + return hash +} + +func (licenseRisk *LicenseRisk) BeforeSave(tx *gorm.DB) (err error) { + hash := licenseRisk.CalculateHash() + licenseRisk.ID = hash + return nil +} diff --git a/internal/database/models/vulnevent_model.go b/internal/database/models/vulnevent_model.go index 8f69738f1..1d05e6534 100644 --- a/internal/database/models/vulnevent_model.go +++ b/internal/database/models/vulnevent_model.go @@ -16,6 +16,7 @@ type VulnType string const ( VulnTypeDependencyVuln VulnType = "dependencyVuln" VulnTypeFirstPartyVuln VulnType = "firstPartyVuln" + VulnTypeLicenseRisk VulnType = "licenseRisk" ) const ( @@ -148,6 +149,7 @@ func (event VulnEvent) Apply(vuln Vuln) { vuln.SetRawRiskAssessment(f) vuln.SetRiskRecalculatedAt(time.Now()) } + } func NewAcceptedEvent(vulnID string, vulnType VulnType, userID, justification string) VulnEvent { diff --git a/internal/database/repositories/component_repository.go b/internal/database/repositories/component_repository.go index 769462cbe..0688230e3 100644 --- a/internal/database/repositories/component_repository.go +++ b/internal/database/repositories/component_repository.go @@ -179,22 +179,22 @@ func (c *componentRepository) GetLicenseDistribution(tx core.DB, assetVersionNam RIGHT JOIN component_dependencies as cd ON c.purl = cd.dependency_purl WHERE EXISTS - (SELECT license_id FROM license_overwrite as lo WHERE lo.component_purl = c.purl) + (SELECT final_license_decision FROM license_risks as lr WHERE lr.component_purl = c.purl AND lr.state = ?) AND asset_version_name = ? AND asset_id = ? GROUP BY c.license`, - assetVersionName, assetID) + models.VulnStateFixed, assetVersionName, assetID) //Components WITHOUT an overwrite otherLicensesQuery := c.GetDB(tx).Raw(`SELECT c.license , COUNT(c.license) as count FROM components as c RIGHT JOIN component_dependencies as cd ON c.purl = cd.dependency_purl WHERE NOT EXISTS - (SELECT license_id FROM license_overwrite as lo WHERE lo.component_purl = c.purl) + (SELECT final_license_decision FROM license_risks as lr WHERE lr.component_purl = c.purl AND lr.state = ?) AND asset_version_name = ? AND asset_id = ? GROUP BY c.license`, - assetVersionName, assetID) + models.VulnStateFixed, assetVersionName, assetID) //We then still need to filter for the right scanner if scannerID != "" { @@ -244,7 +244,7 @@ func licensesToMap(licenses []struct { return licensesMap } -func (c *componentRepository) LoadComponentsWithProject(tx core.DB, overwrittenLicenses []models.LicenseOverwrite, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.ComponentDependency], error) { +func (c *componentRepository) LoadComponentsWithProject(tx core.DB, overwrittenLicenses []models.LicenseRisk, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.ComponentDependency], error) { var componentDependencies []models.ComponentDependency query := c.GetDB(tx).Model(&models.ComponentDependency{}).Joins("Dependency").Joins("Dependency.ComponentProject").Where("asset_version_name = ? AND asset_id = ?", assetVersionName, assetID) @@ -288,7 +288,7 @@ func (c *componentRepository) LoadComponentsWithProject(tx core.DB, overwrittenL // convert all overwritten licenses to a map which maps a purl to a new license isPurlOverwrittenMap := make(map[string]string, len(overwrittenLicenses)) for i := range overwrittenLicenses { - isPurlOverwrittenMap[overwrittenLicenses[i].ComponentPurl] = overwrittenLicenses[i].LicenseID + isPurlOverwrittenMap[overwrittenLicenses[i].ComponentPurl] = overwrittenLicenses[i].FinalLicenseDecision } // now we check if a given component (dependency) is present in the overwrittenMap eg. it needs to be overwritten and flagged as such diff --git a/internal/database/repositories/license_overwrite_repository.go b/internal/database/repositories/license_overwrite_repository.go deleted file mode 100644 index 15515b6a8..000000000 --- a/internal/database/repositories/license_overwrite_repository.go +++ /dev/null @@ -1,51 +0,0 @@ -package repositories - -import ( - "os" - - "github.com/google/uuid" - "github.com/l3montree-dev/devguard/internal/common" - "github.com/l3montree-dev/devguard/internal/core" - "github.com/l3montree-dev/devguard/internal/database/models" - "github.com/package-url/packageurl-go" - "gorm.io/gorm" -) - -type LicenseOverwriteRepository struct { - common.Repository[string, models.LicenseOverwrite, core.DB] - db *gorm.DB -} - -func NewLicenseOverwriteRepository(db core.DB) *LicenseOverwriteRepository { - if os.Getenv("DISABLE_AUTOMIGRATE") != "true" { - if err := db.AutoMigrate(&models.LicenseOverwrite{}); err != nil { - panic(err) - } - } - return &LicenseOverwriteRepository{ - db: db, - Repository: newGormRepository[string, models.LicenseOverwrite](db), - } -} - -func (repository *LicenseOverwriteRepository) GetAllOverwritesForOrganization(orgID uuid.UUID) ([]models.LicenseOverwrite, error) { - var result []models.LicenseOverwrite - err := repository.db.Where("organization_id = ?", orgID).Find(&result).Error - if err != nil { - return result, err - } - return result, nil -} - -func (repository *LicenseOverwriteRepository) MaybeGetOverwriteForComponent(orgID uuid.UUID, pURL packageurl.PackageURL) (models.LicenseOverwrite, error) { - var result models.LicenseOverwrite - err := repository.db.Where("organization_id = ? AND component_purl = ?", orgID, pURL.String()).First(&result).Error - if err != nil { - return result, err - } - return result, nil -} - -func (repository *LicenseOverwriteRepository) DeleteByComponentPurlAndOrgID(orgID uuid.UUID, pURL string) error { - return repository.db.Where("organization_id = ? AND component_purl = ?", orgID, pURL).Delete(&models.LicenseOverwrite{}).Error -} diff --git a/internal/database/repositories/license_risk_repository.go b/internal/database/repositories/license_risk_repository.go new file mode 100644 index 000000000..7104e2c9c --- /dev/null +++ b/internal/database/repositories/license_risk_repository.go @@ -0,0 +1,125 @@ +package repositories + +import ( + "os" + + "github.com/google/uuid" + "github.com/l3montree-dev/devguard/internal/common" + "github.com/l3montree-dev/devguard/internal/core" + "github.com/l3montree-dev/devguard/internal/database/models" + "github.com/package-url/packageurl-go" + "gorm.io/gorm" +) + +type LicenseRiskRepository struct { + common.Repository[string, models.LicenseRisk, core.DB] + db *gorm.DB +} + +func NewLicenseRiskRepository(db core.DB) *LicenseRiskRepository { + if os.Getenv("DISABLE_AUTOMIGRATE") != "true" { + if err := db.AutoMigrate(&models.LicenseRisk{}); err != nil { + panic(err) + } + } + return &LicenseRiskRepository{ + db: db, + Repository: newGormRepository[string, models.LicenseRisk](db), + } +} + +func (repository *LicenseRiskRepository) GetAllLicenseRisksForAssetVersionPaged(tx core.DB, assetID uuid.UUID, assetVersionName string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.LicenseRisk], error) { + var count int64 + var licenseRisks = []models.LicenseRisk{} + + q := repository.Repository.GetDB(tx).Model(&models.LicenseRisk{}).Where("license_risks.asset_version_name = ?", assetVersionName).Where("license_risks.asset_id = ?", assetID) + + // apply filters + for _, f := range filter { + q = q.Where(f.SQL(), f.Value()) + } + if search != "" && len(search) > 2 { + q = q.Where("license_risks.final_license_decision ILIKE ? OR license_risks.component_purl ILIKE ? OR license_risks.scanner_ids ILIKE ?", "%"+search+"%", "%"+search+"%", "%"+search+"%") + } + + err := q.Count(&count).Error + if err != nil { + return core.Paged[models.LicenseRisk]{}, err + } + + err = q.Limit(pageInfo.PageSize).Offset((pageInfo.Page - 1) * pageInfo.PageSize).Find(&licenseRisks).Error + if err != nil { + return core.Paged[models.LicenseRisk]{}, err + } + //TODO: check it + return core.NewPaged(pageInfo, count, licenseRisks), nil +} + +func (repository *LicenseRiskRepository) GetAllLicenseRisksForAssetVersion(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error) { + var result []models.LicenseRisk + err := repository.db.Where("asset_id = ? AND asset_version_name = ?", assetID, assetVersionName).Find(&result).Error + if err != nil { + return result, err + } + return result, nil +} + +func (repository *LicenseRiskRepository) GetAllOverwrittenLicensesForAssetVersion(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error) { + var result []models.LicenseRisk + err := repository.db.Where("asset_id = ? AND asset_version_name = ? AND state = ?", assetID, assetVersionName, models.VulnStateFixed).Find(&result).Error + if err != nil { + return result, err + } + return result, nil +} + +func (repository *LicenseRiskRepository) MaybeGetLicenseOverwriteForComponent(assetID uuid.UUID, assetVersionName string, pURL packageurl.PackageURL) (models.LicenseRisk, error) { + var result models.LicenseRisk + err := repository.db.Where("asset_id = ? AND asset_version_name = ? AND component_purl = ? AND state = ?", assetID, assetVersionName, pURL.String(), models.VulnStateFixed).First(&result).Error + if err != nil { + return result, err + } + return result, nil +} + +func (repository *LicenseRiskRepository) DeleteByComponentPurl(assetID uuid.UUID, assetVersionName string, pURL packageurl.PackageURL) error { + return repository.db.Where("asset_id = ? AND asset_version_name = ? AND component_purl = ?", assetID, assetVersionName, pURL.String()).Delete(&models.LicenseRisk{}).Error +} + +func (repository *LicenseRiskRepository) ListByScanner(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.LicenseRisk, error) { + var licenseRisks = []models.LicenseRisk{} + scannerID = "%" + scannerID + "%" + err := repository.db.Where("asset_version_name = ? AND asset_id = ? AND scanner_ids LIKE ?", assetVersionName, assetID, scannerID).Find(&licenseRisks).Error + if err != nil { + return nil, err + } + return licenseRisks, nil +} + +func (repository *LicenseRiskRepository) ApplyAndSave(tx core.DB, licenseRisk *models.LicenseRisk, vulnEvent *models.VulnEvent) error { + if tx == nil { + // we are not part of a parent transaction - create a new one + return repository.Transaction(func(d core.DB) error { + _, err := repository.applyAndSave(d, licenseRisk, vulnEvent) + return err + }) + } + + _, err := repository.applyAndSave(tx, licenseRisk, vulnEvent) + return err +} + +func (repository *LicenseRiskRepository) applyAndSave(tx core.DB, licenseRisk *models.LicenseRisk, ev *models.VulnEvent) (models.VulnEvent, error) { + ev.Apply(licenseRisk) + + // run the updates in the transaction to keep a valid state + err := repository.Save(tx, licenseRisk) + if err != nil { + return models.VulnEvent{}, err + } + if err := repository.GetDB(tx).Save(ev).Error; err != nil { + return models.VulnEvent{}, err + } + licenseRisk.Events = append(licenseRisk.Events, *ev) + return *ev, nil +} diff --git a/internal/inithelper/intialize_modules.go b/internal/inithelper/intialize_modules.go index 636f15115..dfeba99c6 100644 --- a/internal/inithelper/intialize_modules.go +++ b/internal/inithelper/intialize_modules.go @@ -13,6 +13,13 @@ import ( "github.com/l3montree-dev/devguard/internal/database/repositories" ) +func CreateLicenseRiskService(db core.DB) core.LicenseRiskService { + return vuln.NewLicenseRiskService( + repositories.NewLicenseRiskRepository(db), + repositories.NewVulnEventRepository(db), + ) +} + func CreateStatisticsService(db core.DB) core.StatisticsService { return statistics.NewService( repositories.NewStatisticsRepository(db), @@ -30,6 +37,7 @@ func CreateComponentService(db core.DB, depsDevService core.DepsDevService) core depsDevService, repositories.NewComponentProjectRepository(db), repositories.NewComponentRepository(db), + CreateLicenseRiskService(db), ) return &componentService } @@ -77,7 +85,7 @@ func CreateAssetVersionController(db core.DB, oauth2 map[string]*gitlabint.Gitla repositories.NewComponentRepository(db), CreateDependencyVulnService(db, oauth2, rbac, clientFactory), repositories.NewSupplyChainRepository(db), - repositories.NewLicenseOverwriteRepository(db), + repositories.NewLicenseRiskRepository(db), ) } diff --git a/mocks/mock_ComponentRepository.go b/mocks/mock_ComponentRepository.go index f240ada65..f471cf324 100644 --- a/mocks/mock_ComponentRepository.go +++ b/mocks/mock_ComponentRepository.go @@ -916,7 +916,7 @@ func (_c *ComponentRepository_LoadComponents_Call) RunAndReturn(run func(tx core } // LoadComponentsWithProject provides a mock function for the type ComponentRepository -func (_mock *ComponentRepository) LoadComponentsWithProject(tx core.DB, overwrittenLicenses []models.LicenseOverwrite, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.ComponentDependency], error) { +func (_mock *ComponentRepository) LoadComponentsWithProject(tx core.DB, overwrittenLicenses []models.LicenseRisk, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.ComponentDependency], error) { ret := _mock.Called(tx, overwrittenLicenses, assetVersionName, assetID, scannerID, pageInfo, search, filter, sort) if len(ret) == 0 { @@ -925,15 +925,15 @@ func (_mock *ComponentRepository) LoadComponentsWithProject(tx core.DB, overwrit var r0 core.Paged[models.ComponentDependency] var r1 error - if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseOverwrite, string, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) (core.Paged[models.ComponentDependency], error)); ok { + if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseRisk, string, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) (core.Paged[models.ComponentDependency], error)); ok { return returnFunc(tx, overwrittenLicenses, assetVersionName, assetID, scannerID, pageInfo, search, filter, sort) } - if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseOverwrite, string, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) core.Paged[models.ComponentDependency]); ok { + if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseRisk, string, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) core.Paged[models.ComponentDependency]); ok { r0 = returnFunc(tx, overwrittenLicenses, assetVersionName, assetID, scannerID, pageInfo, search, filter, sort) } else { r0 = ret.Get(0).(core.Paged[models.ComponentDependency]) } - if returnFunc, ok := ret.Get(1).(func(core.DB, []models.LicenseOverwrite, string, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) error); ok { + if returnFunc, ok := ret.Get(1).(func(core.DB, []models.LicenseRisk, string, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) error); ok { r1 = returnFunc(tx, overwrittenLicenses, assetVersionName, assetID, scannerID, pageInfo, search, filter, sort) } else { r1 = ret.Error(1) @@ -948,7 +948,7 @@ type ComponentRepository_LoadComponentsWithProject_Call struct { // LoadComponentsWithProject is a helper method to define mock.On call // - tx core.DB -// - overwrittenLicenses []models.LicenseOverwrite +// - overwrittenLicenses []models.LicenseRisk // - assetVersionName string // - assetID uuid.UUID // - scannerID string @@ -960,15 +960,15 @@ func (_e *ComponentRepository_Expecter) LoadComponentsWithProject(tx interface{} return &ComponentRepository_LoadComponentsWithProject_Call{Call: _e.mock.On("LoadComponentsWithProject", tx, overwrittenLicenses, assetVersionName, assetID, scannerID, pageInfo, search, filter, sort)} } -func (_c *ComponentRepository_LoadComponentsWithProject_Call) Run(run func(tx core.DB, overwrittenLicenses []models.LicenseOverwrite, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery)) *ComponentRepository_LoadComponentsWithProject_Call { +func (_c *ComponentRepository_LoadComponentsWithProject_Call) Run(run func(tx core.DB, overwrittenLicenses []models.LicenseRisk, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery)) *ComponentRepository_LoadComponentsWithProject_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 core.DB if args[0] != nil { arg0 = args[0].(core.DB) } - var arg1 []models.LicenseOverwrite + var arg1 []models.LicenseRisk if args[1] != nil { - arg1 = args[1].([]models.LicenseOverwrite) + arg1 = args[1].([]models.LicenseRisk) } var arg2 string if args[2] != nil { @@ -1018,7 +1018,7 @@ func (_c *ComponentRepository_LoadComponentsWithProject_Call) Return(paged core. return _c } -func (_c *ComponentRepository_LoadComponentsWithProject_Call) RunAndReturn(run func(tx core.DB, overwrittenLicenses []models.LicenseOverwrite, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.ComponentDependency], error)) *ComponentRepository_LoadComponentsWithProject_Call { +func (_c *ComponentRepository_LoadComponentsWithProject_Call) RunAndReturn(run func(tx core.DB, overwrittenLicenses []models.LicenseRisk, assetVersionName string, assetID uuid.UUID, scannerID string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.ComponentDependency], error)) *ComponentRepository_LoadComponentsWithProject_Call { _c.Call.Return(run) return _c } diff --git a/mocks/mock_ComponentService.go b/mocks/mock_ComponentService.go index 4a245e985..e7f60a696 100644 --- a/mocks/mock_ComponentService.go +++ b/mocks/mock_ComponentService.go @@ -5,7 +5,6 @@ package mocks import ( - "github.com/google/uuid" "github.com/l3montree-dev/devguard/internal/database/models" mock "github.com/stretchr/testify/mock" ) @@ -38,8 +37,8 @@ func (_m *ComponentService) EXPECT() *ComponentService_Expecter { } // GetAndSaveLicenseInformation provides a mock function for the type ComponentService -func (_mock *ComponentService) GetAndSaveLicenseInformation(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.Component, error) { - ret := _mock.Called(assetVersionName, assetID, scannerID) +func (_mock *ComponentService) GetAndSaveLicenseInformation(assetVersion models.AssetVersion, scannerID string) ([]models.Component, error) { + ret := _mock.Called(assetVersion, scannerID) if len(ret) == 0 { panic("no return value specified for GetAndSaveLicenseInformation") @@ -47,18 +46,18 @@ func (_mock *ComponentService) GetAndSaveLicenseInformation(assetVersionName str var r0 []models.Component var r1 error - if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, string) ([]models.Component, error)); ok { - return returnFunc(assetVersionName, assetID, scannerID) + if returnFunc, ok := ret.Get(0).(func(models.AssetVersion, string) ([]models.Component, error)); ok { + return returnFunc(assetVersion, scannerID) } - if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, string) []models.Component); ok { - r0 = returnFunc(assetVersionName, assetID, scannerID) + if returnFunc, ok := ret.Get(0).(func(models.AssetVersion, string) []models.Component); ok { + r0 = returnFunc(assetVersion, scannerID) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]models.Component) } } - if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID, string) error); ok { - r1 = returnFunc(assetVersionName, assetID, scannerID) + if returnFunc, ok := ret.Get(1).(func(models.AssetVersion, string) error); ok { + r1 = returnFunc(assetVersion, scannerID) } else { r1 = ret.Error(1) } @@ -71,31 +70,25 @@ type ComponentService_GetAndSaveLicenseInformation_Call struct { } // GetAndSaveLicenseInformation is a helper method to define mock.On call -// - assetVersionName string -// - assetID uuid.UUID +// - assetVersion models.AssetVersion // - scannerID string -func (_e *ComponentService_Expecter) GetAndSaveLicenseInformation(assetVersionName interface{}, assetID interface{}, scannerID interface{}) *ComponentService_GetAndSaveLicenseInformation_Call { - return &ComponentService_GetAndSaveLicenseInformation_Call{Call: _e.mock.On("GetAndSaveLicenseInformation", assetVersionName, assetID, scannerID)} +func (_e *ComponentService_Expecter) GetAndSaveLicenseInformation(assetVersion interface{}, scannerID interface{}) *ComponentService_GetAndSaveLicenseInformation_Call { + return &ComponentService_GetAndSaveLicenseInformation_Call{Call: _e.mock.On("GetAndSaveLicenseInformation", assetVersion, scannerID)} } -func (_c *ComponentService_GetAndSaveLicenseInformation_Call) Run(run func(assetVersionName string, assetID uuid.UUID, scannerID string)) *ComponentService_GetAndSaveLicenseInformation_Call { +func (_c *ComponentService_GetAndSaveLicenseInformation_Call) Run(run func(assetVersion models.AssetVersion, scannerID string)) *ComponentService_GetAndSaveLicenseInformation_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 string + var arg0 models.AssetVersion if args[0] != nil { - arg0 = args[0].(string) + arg0 = args[0].(models.AssetVersion) } - var arg1 uuid.UUID + var arg1 string if args[1] != nil { - arg1 = args[1].(uuid.UUID) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) + arg1 = args[1].(string) } run( arg0, arg1, - arg2, ) }) return _c @@ -106,7 +99,7 @@ func (_c *ComponentService_GetAndSaveLicenseInformation_Call) Return(components return _c } -func (_c *ComponentService_GetAndSaveLicenseInformation_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.Component, error)) *ComponentService_GetAndSaveLicenseInformation_Call { +func (_c *ComponentService_GetAndSaveLicenseInformation_Call) RunAndReturn(run func(assetVersion models.AssetVersion, scannerID string) ([]models.Component, error)) *ComponentService_GetAndSaveLicenseInformation_Call { _c.Call.Return(run) return _c } diff --git a/mocks/mock_LicenseOverwriteRepository.go b/mocks/mock_LicenseOverwriteRepository.go deleted file mode 100644 index 330234778..000000000 --- a/mocks/mock_LicenseOverwriteRepository.go +++ /dev/null @@ -1,1015 +0,0 @@ -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery -// template: testify - -package mocks - -import ( - "github.com/google/uuid" - "github.com/l3montree-dev/devguard/internal/core" - "github.com/l3montree-dev/devguard/internal/database/models" - "github.com/package-url/packageurl-go" - mock "github.com/stretchr/testify/mock" - "gorm.io/gorm/clause" -) - -// NewLicenseOverwriteRepository creates a new instance of LicenseOverwriteRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewLicenseOverwriteRepository(t interface { - mock.TestingT - Cleanup(func()) -}) *LicenseOverwriteRepository { - mock := &LicenseOverwriteRepository{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - -// LicenseOverwriteRepository is an autogenerated mock type for the LicenseOverwriteRepository type -type LicenseOverwriteRepository struct { - mock.Mock -} - -type LicenseOverwriteRepository_Expecter struct { - mock *mock.Mock -} - -func (_m *LicenseOverwriteRepository) EXPECT() *LicenseOverwriteRepository_Expecter { - return &LicenseOverwriteRepository_Expecter{mock: &_m.Mock} -} - -// Activate provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) Activate(tx core.DB, id string) error { - ret := _mock.Called(tx, id) - - if len(ret) == 0 { - panic("no return value specified for Activate") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(core.DB, string) error); ok { - r0 = returnFunc(tx, id) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_Activate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Activate' -type LicenseOverwriteRepository_Activate_Call struct { - *mock.Call -} - -// Activate is a helper method to define mock.On call -// - tx core.DB -// - id string -func (_e *LicenseOverwriteRepository_Expecter) Activate(tx interface{}, id interface{}) *LicenseOverwriteRepository_Activate_Call { - return &LicenseOverwriteRepository_Activate_Call{Call: _e.mock.On("Activate", tx, id)} -} - -func (_c *LicenseOverwriteRepository_Activate_Call) Run(run func(tx core.DB, id string)) *LicenseOverwriteRepository_Activate_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 core.DB - if args[0] != nil { - arg0 = args[0].(core.DB) - } - var arg1 string - if args[1] != nil { - arg1 = args[1].(string) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_Activate_Call) Return(err error) *LicenseOverwriteRepository_Activate_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *LicenseOverwriteRepository_Activate_Call { - _c.Call.Return(run) - return _c -} - -// All provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) All() ([]models.LicenseOverwrite, error) { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for All") - } - - var r0 []models.LicenseOverwrite - var r1 error - if returnFunc, ok := ret.Get(0).(func() ([]models.LicenseOverwrite, error)); ok { - return returnFunc() - } - if returnFunc, ok := ret.Get(0).(func() []models.LicenseOverwrite); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]models.LicenseOverwrite) - } - } - if returnFunc, ok := ret.Get(1).(func() error); ok { - r1 = returnFunc() - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - -// LicenseOverwriteRepository_All_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'All' -type LicenseOverwriteRepository_All_Call struct { - *mock.Call -} - -// All is a helper method to define mock.On call -func (_e *LicenseOverwriteRepository_Expecter) All() *LicenseOverwriteRepository_All_Call { - return &LicenseOverwriteRepository_All_Call{Call: _e.mock.On("All")} -} - -func (_c *LicenseOverwriteRepository_All_Call) Run(run func()) *LicenseOverwriteRepository_All_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *LicenseOverwriteRepository_All_Call) Return(licenseOverwrites []models.LicenseOverwrite, err error) *LicenseOverwriteRepository_All_Call { - _c.Call.Return(licenseOverwrites, err) - return _c -} - -func (_c *LicenseOverwriteRepository_All_Call) RunAndReturn(run func() ([]models.LicenseOverwrite, error)) *LicenseOverwriteRepository_All_Call { - _c.Call.Return(run) - return _c -} - -// Begin provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) Begin() core.DB { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Begin") - } - - var r0 core.DB - if returnFunc, ok := ret.Get(0).(func() core.DB); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(core.DB) - } - } - return r0 -} - -// LicenseOverwriteRepository_Begin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Begin' -type LicenseOverwriteRepository_Begin_Call struct { - *mock.Call -} - -// Begin is a helper method to define mock.On call -func (_e *LicenseOverwriteRepository_Expecter) Begin() *LicenseOverwriteRepository_Begin_Call { - return &LicenseOverwriteRepository_Begin_Call{Call: _e.mock.On("Begin")} -} - -func (_c *LicenseOverwriteRepository_Begin_Call) Run(run func()) *LicenseOverwriteRepository_Begin_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *LicenseOverwriteRepository_Begin_Call) Return(v core.DB) *LicenseOverwriteRepository_Begin_Call { - _c.Call.Return(v) - return _c -} - -func (_c *LicenseOverwriteRepository_Begin_Call) RunAndReturn(run func() core.DB) *LicenseOverwriteRepository_Begin_Call { - _c.Call.Return(run) - return _c -} - -// Create provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) Create(tx core.DB, t *models.LicenseOverwrite) error { - ret := _mock.Called(tx, t) - - if len(ret) == 0 { - panic("no return value specified for Create") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(core.DB, *models.LicenseOverwrite) error); ok { - r0 = returnFunc(tx, t) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' -type LicenseOverwriteRepository_Create_Call struct { - *mock.Call -} - -// Create is a helper method to define mock.On call -// - tx core.DB -// - t *models.LicenseOverwrite -func (_e *LicenseOverwriteRepository_Expecter) Create(tx interface{}, t interface{}) *LicenseOverwriteRepository_Create_Call { - return &LicenseOverwriteRepository_Create_Call{Call: _e.mock.On("Create", tx, t)} -} - -func (_c *LicenseOverwriteRepository_Create_Call) Run(run func(tx core.DB, t *models.LicenseOverwrite)) *LicenseOverwriteRepository_Create_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 core.DB - if args[0] != nil { - arg0 = args[0].(core.DB) - } - var arg1 *models.LicenseOverwrite - if args[1] != nil { - arg1 = args[1].(*models.LicenseOverwrite) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_Create_Call) Return(err error) *LicenseOverwriteRepository_Create_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.LicenseOverwrite) error) *LicenseOverwriteRepository_Create_Call { - _c.Call.Return(run) - return _c -} - -// CreateBatch provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) CreateBatch(tx core.DB, ts []models.LicenseOverwrite) error { - ret := _mock.Called(tx, ts) - - if len(ret) == 0 { - panic("no return value specified for CreateBatch") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseOverwrite) error); ok { - r0 = returnFunc(tx, ts) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_CreateBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBatch' -type LicenseOverwriteRepository_CreateBatch_Call struct { - *mock.Call -} - -// CreateBatch is a helper method to define mock.On call -// - tx core.DB -// - ts []models.LicenseOverwrite -func (_e *LicenseOverwriteRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *LicenseOverwriteRepository_CreateBatch_Call { - return &LicenseOverwriteRepository_CreateBatch_Call{Call: _e.mock.On("CreateBatch", tx, ts)} -} - -func (_c *LicenseOverwriteRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.LicenseOverwrite)) *LicenseOverwriteRepository_CreateBatch_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 core.DB - if args[0] != nil { - arg0 = args[0].(core.DB) - } - var arg1 []models.LicenseOverwrite - if args[1] != nil { - arg1 = args[1].([]models.LicenseOverwrite) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_CreateBatch_Call) Return(err error) *LicenseOverwriteRepository_CreateBatch_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.LicenseOverwrite) error) *LicenseOverwriteRepository_CreateBatch_Call { - _c.Call.Return(run) - return _c -} - -// Delete provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) Delete(tx core.DB, id string) error { - ret := _mock.Called(tx, id) - - if len(ret) == 0 { - panic("no return value specified for Delete") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(core.DB, string) error); ok { - r0 = returnFunc(tx, id) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' -type LicenseOverwriteRepository_Delete_Call struct { - *mock.Call -} - -// Delete is a helper method to define mock.On call -// - tx core.DB -// - id string -func (_e *LicenseOverwriteRepository_Expecter) Delete(tx interface{}, id interface{}) *LicenseOverwriteRepository_Delete_Call { - return &LicenseOverwriteRepository_Delete_Call{Call: _e.mock.On("Delete", tx, id)} -} - -func (_c *LicenseOverwriteRepository_Delete_Call) Run(run func(tx core.DB, id string)) *LicenseOverwriteRepository_Delete_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 core.DB - if args[0] != nil { - arg0 = args[0].(core.DB) - } - var arg1 string - if args[1] != nil { - arg1 = args[1].(string) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_Delete_Call) Return(err error) *LicenseOverwriteRepository_Delete_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *LicenseOverwriteRepository_Delete_Call { - _c.Call.Return(run) - return _c -} - -// DeleteBatch provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) DeleteBatch(tx core.DB, ids []models.LicenseOverwrite) error { - ret := _mock.Called(tx, ids) - - if len(ret) == 0 { - panic("no return value specified for DeleteBatch") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseOverwrite) error); ok { - r0 = returnFunc(tx, ids) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_DeleteBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBatch' -type LicenseOverwriteRepository_DeleteBatch_Call struct { - *mock.Call -} - -// DeleteBatch is a helper method to define mock.On call -// - tx core.DB -// - ids []models.LicenseOverwrite -func (_e *LicenseOverwriteRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *LicenseOverwriteRepository_DeleteBatch_Call { - return &LicenseOverwriteRepository_DeleteBatch_Call{Call: _e.mock.On("DeleteBatch", tx, ids)} -} - -func (_c *LicenseOverwriteRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.LicenseOverwrite)) *LicenseOverwriteRepository_DeleteBatch_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 core.DB - if args[0] != nil { - arg0 = args[0].(core.DB) - } - var arg1 []models.LicenseOverwrite - if args[1] != nil { - arg1 = args[1].([]models.LicenseOverwrite) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_DeleteBatch_Call) Return(err error) *LicenseOverwriteRepository_DeleteBatch_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.LicenseOverwrite) error) *LicenseOverwriteRepository_DeleteBatch_Call { - _c.Call.Return(run) - return _c -} - -// DeleteByComponentPurlAndOrgID provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) DeleteByComponentPurlAndOrgID(orgID uuid.UUID, purl string) error { - ret := _mock.Called(orgID, purl) - - if len(ret) == 0 { - panic("no return value specified for DeleteByComponentPurlAndOrgID") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(uuid.UUID, string) error); ok { - r0 = returnFunc(orgID, purl) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByComponentPurlAndOrgID' -type LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call struct { - *mock.Call -} - -// DeleteByComponentPurlAndOrgID is a helper method to define mock.On call -// - orgID uuid.UUID -// - purl string -func (_e *LicenseOverwriteRepository_Expecter) DeleteByComponentPurlAndOrgID(orgID interface{}, purl interface{}) *LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call { - return &LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call{Call: _e.mock.On("DeleteByComponentPurlAndOrgID", orgID, purl)} -} - -func (_c *LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call) Run(run func(orgID uuid.UUID, purl string)) *LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 uuid.UUID - if args[0] != nil { - arg0 = args[0].(uuid.UUID) - } - var arg1 string - if args[1] != nil { - arg1 = args[1].(string) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call) Return(err error) *LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call) RunAndReturn(run func(orgID uuid.UUID, purl string) error) *LicenseOverwriteRepository_DeleteByComponentPurlAndOrgID_Call { - _c.Call.Return(run) - return _c -} - -// GetAllOverwritesForOrganization provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) GetAllOverwritesForOrganization(orgID uuid.UUID) ([]models.LicenseOverwrite, error) { - ret := _mock.Called(orgID) - - if len(ret) == 0 { - panic("no return value specified for GetAllOverwritesForOrganization") - } - - var r0 []models.LicenseOverwrite - var r1 error - if returnFunc, ok := ret.Get(0).(func(uuid.UUID) ([]models.LicenseOverwrite, error)); ok { - return returnFunc(orgID) - } - if returnFunc, ok := ret.Get(0).(func(uuid.UUID) []models.LicenseOverwrite); ok { - r0 = returnFunc(orgID) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]models.LicenseOverwrite) - } - } - if returnFunc, ok := ret.Get(1).(func(uuid.UUID) error); ok { - r1 = returnFunc(orgID) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - -// LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllOverwritesForOrganization' -type LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call struct { - *mock.Call -} - -// GetAllOverwritesForOrganization is a helper method to define mock.On call -// - orgID uuid.UUID -func (_e *LicenseOverwriteRepository_Expecter) GetAllOverwritesForOrganization(orgID interface{}) *LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call { - return &LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call{Call: _e.mock.On("GetAllOverwritesForOrganization", orgID)} -} - -func (_c *LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call) Run(run func(orgID uuid.UUID)) *LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 uuid.UUID - if args[0] != nil { - arg0 = args[0].(uuid.UUID) - } - run( - arg0, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call) Return(licenseOverwrites []models.LicenseOverwrite, err error) *LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call { - _c.Call.Return(licenseOverwrites, err) - return _c -} - -func (_c *LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call) RunAndReturn(run func(orgID uuid.UUID) ([]models.LicenseOverwrite, error)) *LicenseOverwriteRepository_GetAllOverwritesForOrganization_Call { - _c.Call.Return(run) - return _c -} - -// GetDB provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) GetDB(tx core.DB) core.DB { - ret := _mock.Called(tx) - - if len(ret) == 0 { - panic("no return value specified for GetDB") - } - - var r0 core.DB - if returnFunc, ok := ret.Get(0).(func(core.DB) core.DB); ok { - r0 = returnFunc(tx) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(core.DB) - } - } - return r0 -} - -// LicenseOverwriteRepository_GetDB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDB' -type LicenseOverwriteRepository_GetDB_Call struct { - *mock.Call -} - -// GetDB is a helper method to define mock.On call -// - tx core.DB -func (_e *LicenseOverwriteRepository_Expecter) GetDB(tx interface{}) *LicenseOverwriteRepository_GetDB_Call { - return &LicenseOverwriteRepository_GetDB_Call{Call: _e.mock.On("GetDB", tx)} -} - -func (_c *LicenseOverwriteRepository_GetDB_Call) Run(run func(tx core.DB)) *LicenseOverwriteRepository_GetDB_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 core.DB - if args[0] != nil { - arg0 = args[0].(core.DB) - } - run( - arg0, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_GetDB_Call) Return(v core.DB) *LicenseOverwriteRepository_GetDB_Call { - _c.Call.Return(v) - return _c -} - -func (_c *LicenseOverwriteRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *LicenseOverwriteRepository_GetDB_Call { - _c.Call.Return(run) - return _c -} - -// List provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) List(ids []string) ([]models.LicenseOverwrite, error) { - ret := _mock.Called(ids) - - if len(ret) == 0 { - panic("no return value specified for List") - } - - var r0 []models.LicenseOverwrite - var r1 error - if returnFunc, ok := ret.Get(0).(func([]string) ([]models.LicenseOverwrite, error)); ok { - return returnFunc(ids) - } - if returnFunc, ok := ret.Get(0).(func([]string) []models.LicenseOverwrite); ok { - r0 = returnFunc(ids) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]models.LicenseOverwrite) - } - } - if returnFunc, ok := ret.Get(1).(func([]string) error); ok { - r1 = returnFunc(ids) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - -// LicenseOverwriteRepository_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' -type LicenseOverwriteRepository_List_Call struct { - *mock.Call -} - -// List is a helper method to define mock.On call -// - ids []string -func (_e *LicenseOverwriteRepository_Expecter) List(ids interface{}) *LicenseOverwriteRepository_List_Call { - return &LicenseOverwriteRepository_List_Call{Call: _e.mock.On("List", ids)} -} - -func (_c *LicenseOverwriteRepository_List_Call) Run(run func(ids []string)) *LicenseOverwriteRepository_List_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 []string - if args[0] != nil { - arg0 = args[0].([]string) - } - run( - arg0, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_List_Call) Return(licenseOverwrites []models.LicenseOverwrite, err error) *LicenseOverwriteRepository_List_Call { - _c.Call.Return(licenseOverwrites, err) - return _c -} - -func (_c *LicenseOverwriteRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.LicenseOverwrite, error)) *LicenseOverwriteRepository_List_Call { - _c.Call.Return(run) - return _c -} - -// MaybeGetOverwriteForComponent provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) MaybeGetOverwriteForComponent(orgID uuid.UUID, pURL packageurl.PackageURL) (models.LicenseOverwrite, error) { - ret := _mock.Called(orgID, pURL) - - if len(ret) == 0 { - panic("no return value specified for MaybeGetOverwriteForComponent") - } - - var r0 models.LicenseOverwrite - var r1 error - if returnFunc, ok := ret.Get(0).(func(uuid.UUID, packageurl.PackageURL) (models.LicenseOverwrite, error)); ok { - return returnFunc(orgID, pURL) - } - if returnFunc, ok := ret.Get(0).(func(uuid.UUID, packageurl.PackageURL) models.LicenseOverwrite); ok { - r0 = returnFunc(orgID, pURL) - } else { - r0 = ret.Get(0).(models.LicenseOverwrite) - } - if returnFunc, ok := ret.Get(1).(func(uuid.UUID, packageurl.PackageURL) error); ok { - r1 = returnFunc(orgID, pURL) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - -// LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MaybeGetOverwriteForComponent' -type LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call struct { - *mock.Call -} - -// MaybeGetOverwriteForComponent is a helper method to define mock.On call -// - orgID uuid.UUID -// - pURL packageurl.PackageURL -func (_e *LicenseOverwriteRepository_Expecter) MaybeGetOverwriteForComponent(orgID interface{}, pURL interface{}) *LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call { - return &LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call{Call: _e.mock.On("MaybeGetOverwriteForComponent", orgID, pURL)} -} - -func (_c *LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call) Run(run func(orgID uuid.UUID, pURL packageurl.PackageURL)) *LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 uuid.UUID - if args[0] != nil { - arg0 = args[0].(uuid.UUID) - } - var arg1 packageurl.PackageURL - if args[1] != nil { - arg1 = args[1].(packageurl.PackageURL) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call) Return(licenseOverwrite models.LicenseOverwrite, err error) *LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call { - _c.Call.Return(licenseOverwrite, err) - return _c -} - -func (_c *LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call) RunAndReturn(run func(orgID uuid.UUID, pURL packageurl.PackageURL) (models.LicenseOverwrite, error)) *LicenseOverwriteRepository_MaybeGetOverwriteForComponent_Call { - _c.Call.Return(run) - return _c -} - -// Read provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) Read(id string) (models.LicenseOverwrite, error) { - ret := _mock.Called(id) - - if len(ret) == 0 { - panic("no return value specified for Read") - } - - var r0 models.LicenseOverwrite - var r1 error - if returnFunc, ok := ret.Get(0).(func(string) (models.LicenseOverwrite, error)); ok { - return returnFunc(id) - } - if returnFunc, ok := ret.Get(0).(func(string) models.LicenseOverwrite); ok { - r0 = returnFunc(id) - } else { - r0 = ret.Get(0).(models.LicenseOverwrite) - } - if returnFunc, ok := ret.Get(1).(func(string) error); ok { - r1 = returnFunc(id) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - -// LicenseOverwriteRepository_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' -type LicenseOverwriteRepository_Read_Call struct { - *mock.Call -} - -// Read is a helper method to define mock.On call -// - id string -func (_e *LicenseOverwriteRepository_Expecter) Read(id interface{}) *LicenseOverwriteRepository_Read_Call { - return &LicenseOverwriteRepository_Read_Call{Call: _e.mock.On("Read", id)} -} - -func (_c *LicenseOverwriteRepository_Read_Call) Run(run func(id string)) *LicenseOverwriteRepository_Read_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 string - if args[0] != nil { - arg0 = args[0].(string) - } - run( - arg0, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_Read_Call) Return(licenseOverwrite models.LicenseOverwrite, err error) *LicenseOverwriteRepository_Read_Call { - _c.Call.Return(licenseOverwrite, err) - return _c -} - -func (_c *LicenseOverwriteRepository_Read_Call) RunAndReturn(run func(id string) (models.LicenseOverwrite, error)) *LicenseOverwriteRepository_Read_Call { - _c.Call.Return(run) - return _c -} - -// Save provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) Save(tx core.DB, t *models.LicenseOverwrite) error { - ret := _mock.Called(tx, t) - - if len(ret) == 0 { - panic("no return value specified for Save") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(core.DB, *models.LicenseOverwrite) error); ok { - r0 = returnFunc(tx, t) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save' -type LicenseOverwriteRepository_Save_Call struct { - *mock.Call -} - -// Save is a helper method to define mock.On call -// - tx core.DB -// - t *models.LicenseOverwrite -func (_e *LicenseOverwriteRepository_Expecter) Save(tx interface{}, t interface{}) *LicenseOverwriteRepository_Save_Call { - return &LicenseOverwriteRepository_Save_Call{Call: _e.mock.On("Save", tx, t)} -} - -func (_c *LicenseOverwriteRepository_Save_Call) Run(run func(tx core.DB, t *models.LicenseOverwrite)) *LicenseOverwriteRepository_Save_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 core.DB - if args[0] != nil { - arg0 = args[0].(core.DB) - } - var arg1 *models.LicenseOverwrite - if args[1] != nil { - arg1 = args[1].(*models.LicenseOverwrite) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_Save_Call) Return(err error) *LicenseOverwriteRepository_Save_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.LicenseOverwrite) error) *LicenseOverwriteRepository_Save_Call { - _c.Call.Return(run) - return _c -} - -// SaveBatch provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) SaveBatch(tx core.DB, ts []models.LicenseOverwrite) error { - ret := _mock.Called(tx, ts) - - if len(ret) == 0 { - panic("no return value specified for SaveBatch") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseOverwrite) error); ok { - r0 = returnFunc(tx, ts) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_SaveBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveBatch' -type LicenseOverwriteRepository_SaveBatch_Call struct { - *mock.Call -} - -// SaveBatch is a helper method to define mock.On call -// - tx core.DB -// - ts []models.LicenseOverwrite -func (_e *LicenseOverwriteRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *LicenseOverwriteRepository_SaveBatch_Call { - return &LicenseOverwriteRepository_SaveBatch_Call{Call: _e.mock.On("SaveBatch", tx, ts)} -} - -func (_c *LicenseOverwriteRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.LicenseOverwrite)) *LicenseOverwriteRepository_SaveBatch_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 core.DB - if args[0] != nil { - arg0 = args[0].(core.DB) - } - var arg1 []models.LicenseOverwrite - if args[1] != nil { - arg1 = args[1].([]models.LicenseOverwrite) - } - run( - arg0, - arg1, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_SaveBatch_Call) Return(err error) *LicenseOverwriteRepository_SaveBatch_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.LicenseOverwrite) error) *LicenseOverwriteRepository_SaveBatch_Call { - _c.Call.Return(run) - return _c -} - -// Transaction provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) Transaction(fn func(tx core.DB) error) error { - ret := _mock.Called(fn) - - if len(ret) == 0 { - panic("no return value specified for Transaction") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(func(tx core.DB) error) error); ok { - r0 = returnFunc(fn) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_Transaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Transaction' -type LicenseOverwriteRepository_Transaction_Call struct { - *mock.Call -} - -// Transaction is a helper method to define mock.On call -// - fn func(tx core.DB) error -func (_e *LicenseOverwriteRepository_Expecter) Transaction(fn interface{}) *LicenseOverwriteRepository_Transaction_Call { - return &LicenseOverwriteRepository_Transaction_Call{Call: _e.mock.On("Transaction", fn)} -} - -func (_c *LicenseOverwriteRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *LicenseOverwriteRepository_Transaction_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 func(tx core.DB) error - if args[0] != nil { - arg0 = args[0].(func(tx core.DB) error) - } - run( - arg0, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_Transaction_Call) Return(err error) *LicenseOverwriteRepository_Transaction_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *LicenseOverwriteRepository_Transaction_Call { - _c.Call.Return(run) - return _c -} - -// Upsert provides a mock function for the type LicenseOverwriteRepository -func (_mock *LicenseOverwriteRepository) Upsert(t *[]*models.LicenseOverwrite, conflictingColumns []clause.Column, updateOnly []string) error { - ret := _mock.Called(t, conflictingColumns, updateOnly) - - if len(ret) == 0 { - panic("no return value specified for Upsert") - } - - var r0 error - if returnFunc, ok := ret.Get(0).(func(*[]*models.LicenseOverwrite, []clause.Column, []string) error); ok { - r0 = returnFunc(t, conflictingColumns, updateOnly) - } else { - r0 = ret.Error(0) - } - return r0 -} - -// LicenseOverwriteRepository_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert' -type LicenseOverwriteRepository_Upsert_Call struct { - *mock.Call -} - -// Upsert is a helper method to define mock.On call -// - t *[]*models.LicenseOverwrite -// - conflictingColumns []clause.Column -// - updateOnly []string -func (_e *LicenseOverwriteRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *LicenseOverwriteRepository_Upsert_Call { - return &LicenseOverwriteRepository_Upsert_Call{Call: _e.mock.On("Upsert", t, conflictingColumns, updateOnly)} -} - -func (_c *LicenseOverwriteRepository_Upsert_Call) Run(run func(t *[]*models.LicenseOverwrite, conflictingColumns []clause.Column, updateOnly []string)) *LicenseOverwriteRepository_Upsert_Call { - _c.Call.Run(func(args mock.Arguments) { - var arg0 *[]*models.LicenseOverwrite - if args[0] != nil { - arg0 = args[0].(*[]*models.LicenseOverwrite) - } - var arg1 []clause.Column - if args[1] != nil { - arg1 = args[1].([]clause.Column) - } - var arg2 []string - if args[2] != nil { - arg2 = args[2].([]string) - } - run( - arg0, - arg1, - arg2, - ) - }) - return _c -} - -func (_c *LicenseOverwriteRepository_Upsert_Call) Return(err error) *LicenseOverwriteRepository_Upsert_Call { - _c.Call.Return(err) - return _c -} - -func (_c *LicenseOverwriteRepository_Upsert_Call) RunAndReturn(run func(t *[]*models.LicenseOverwrite, conflictingColumns []clause.Column, updateOnly []string) error) *LicenseOverwriteRepository_Upsert_Call { - _c.Call.Return(run) - return _c -} diff --git a/mocks/mock_LicenseRiskRepository.go b/mocks/mock_LicenseRiskRepository.go new file mode 100644 index 000000000..1d94194ee --- /dev/null +++ b/mocks/mock_LicenseRiskRepository.go @@ -0,0 +1,1334 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "github.com/google/uuid" + "github.com/l3montree-dev/devguard/internal/core" + "github.com/l3montree-dev/devguard/internal/database/models" + "github.com/package-url/packageurl-go" + mock "github.com/stretchr/testify/mock" + "gorm.io/gorm/clause" +) + +// NewLicenseRiskRepository creates a new instance of LicenseRiskRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewLicenseRiskRepository(t interface { + mock.TestingT + Cleanup(func()) +}) *LicenseRiskRepository { + mock := &LicenseRiskRepository{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// LicenseRiskRepository is an autogenerated mock type for the LicenseRiskRepository type +type LicenseRiskRepository struct { + mock.Mock +} + +type LicenseRiskRepository_Expecter struct { + mock *mock.Mock +} + +func (_m *LicenseRiskRepository) EXPECT() *LicenseRiskRepository_Expecter { + return &LicenseRiskRepository_Expecter{mock: &_m.Mock} +} + +// Activate provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) Activate(tx core.DB, id string) error { + ret := _mock.Called(tx, id) + + if len(ret) == 0 { + panic("no return value specified for Activate") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(core.DB, string) error); ok { + r0 = returnFunc(tx, id) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_Activate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Activate' +type LicenseRiskRepository_Activate_Call struct { + *mock.Call +} + +// Activate is a helper method to define mock.On call +// - tx core.DB +// - id string +func (_e *LicenseRiskRepository_Expecter) Activate(tx interface{}, id interface{}) *LicenseRiskRepository_Activate_Call { + return &LicenseRiskRepository_Activate_Call{Call: _e.mock.On("Activate", tx, id)} +} + +func (_c *LicenseRiskRepository_Activate_Call) Run(run func(tx core.DB, id string)) *LicenseRiskRepository_Activate_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_Activate_Call) Return(err error) *LicenseRiskRepository_Activate_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_Activate_Call) RunAndReturn(run func(tx core.DB, id string) error) *LicenseRiskRepository_Activate_Call { + _c.Call.Return(run) + return _c +} + +// All provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) All() ([]models.LicenseRisk, error) { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for All") + } + + var r0 []models.LicenseRisk + var r1 error + if returnFunc, ok := ret.Get(0).(func() ([]models.LicenseRisk, error)); ok { + return returnFunc() + } + if returnFunc, ok := ret.Get(0).(func() []models.LicenseRisk); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]models.LicenseRisk) + } + } + if returnFunc, ok := ret.Get(1).(func() error); ok { + r1 = returnFunc() + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskRepository_All_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'All' +type LicenseRiskRepository_All_Call struct { + *mock.Call +} + +// All is a helper method to define mock.On call +func (_e *LicenseRiskRepository_Expecter) All() *LicenseRiskRepository_All_Call { + return &LicenseRiskRepository_All_Call{Call: _e.mock.On("All")} +} + +func (_c *LicenseRiskRepository_All_Call) Run(run func()) *LicenseRiskRepository_All_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *LicenseRiskRepository_All_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_All_Call { + _c.Call.Return(licenseRisks, err) + return _c +} + +func (_c *LicenseRiskRepository_All_Call) RunAndReturn(run func() ([]models.LicenseRisk, error)) *LicenseRiskRepository_All_Call { + _c.Call.Return(run) + return _c +} + +// ApplyAndSave provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) ApplyAndSave(tx core.DB, licenseRisk *models.LicenseRisk, vulnEvent *models.VulnEvent) error { + ret := _mock.Called(tx, licenseRisk, vulnEvent) + + if len(ret) == 0 { + panic("no return value specified for ApplyAndSave") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(core.DB, *models.LicenseRisk, *models.VulnEvent) error); ok { + r0 = returnFunc(tx, licenseRisk, vulnEvent) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_ApplyAndSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyAndSave' +type LicenseRiskRepository_ApplyAndSave_Call struct { + *mock.Call +} + +// ApplyAndSave is a helper method to define mock.On call +// - tx core.DB +// - licenseRisk *models.LicenseRisk +// - vulnEvent *models.VulnEvent +func (_e *LicenseRiskRepository_Expecter) ApplyAndSave(tx interface{}, licenseRisk interface{}, vulnEvent interface{}) *LicenseRiskRepository_ApplyAndSave_Call { + return &LicenseRiskRepository_ApplyAndSave_Call{Call: _e.mock.On("ApplyAndSave", tx, licenseRisk, vulnEvent)} +} + +func (_c *LicenseRiskRepository_ApplyAndSave_Call) Run(run func(tx core.DB, licenseRisk *models.LicenseRisk, vulnEvent *models.VulnEvent)) *LicenseRiskRepository_ApplyAndSave_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 *models.LicenseRisk + if args[1] != nil { + arg1 = args[1].(*models.LicenseRisk) + } + var arg2 *models.VulnEvent + if args[2] != nil { + arg2 = args[2].(*models.VulnEvent) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_ApplyAndSave_Call) Return(err error) *LicenseRiskRepository_ApplyAndSave_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_ApplyAndSave_Call) RunAndReturn(run func(tx core.DB, licenseRisk *models.LicenseRisk, vulnEvent *models.VulnEvent) error) *LicenseRiskRepository_ApplyAndSave_Call { + _c.Call.Return(run) + return _c +} + +// Begin provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) Begin() core.DB { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Begin") + } + + var r0 core.DB + if returnFunc, ok := ret.Get(0).(func() core.DB); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.DB) + } + } + return r0 +} + +// LicenseRiskRepository_Begin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Begin' +type LicenseRiskRepository_Begin_Call struct { + *mock.Call +} + +// Begin is a helper method to define mock.On call +func (_e *LicenseRiskRepository_Expecter) Begin() *LicenseRiskRepository_Begin_Call { + return &LicenseRiskRepository_Begin_Call{Call: _e.mock.On("Begin")} +} + +func (_c *LicenseRiskRepository_Begin_Call) Run(run func()) *LicenseRiskRepository_Begin_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *LicenseRiskRepository_Begin_Call) Return(v core.DB) *LicenseRiskRepository_Begin_Call { + _c.Call.Return(v) + return _c +} + +func (_c *LicenseRiskRepository_Begin_Call) RunAndReturn(run func() core.DB) *LicenseRiskRepository_Begin_Call { + _c.Call.Return(run) + return _c +} + +// Create provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) Create(tx core.DB, t *models.LicenseRisk) error { + ret := _mock.Called(tx, t) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(core.DB, *models.LicenseRisk) error); ok { + r0 = returnFunc(tx, t) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type LicenseRiskRepository_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - tx core.DB +// - t *models.LicenseRisk +func (_e *LicenseRiskRepository_Expecter) Create(tx interface{}, t interface{}) *LicenseRiskRepository_Create_Call { + return &LicenseRiskRepository_Create_Call{Call: _e.mock.On("Create", tx, t)} +} + +func (_c *LicenseRiskRepository_Create_Call) Run(run func(tx core.DB, t *models.LicenseRisk)) *LicenseRiskRepository_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 *models.LicenseRisk + if args[1] != nil { + arg1 = args[1].(*models.LicenseRisk) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_Create_Call) Return(err error) *LicenseRiskRepository_Create_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_Create_Call) RunAndReturn(run func(tx core.DB, t *models.LicenseRisk) error) *LicenseRiskRepository_Create_Call { + _c.Call.Return(run) + return _c +} + +// CreateBatch provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) CreateBatch(tx core.DB, ts []models.LicenseRisk) error { + ret := _mock.Called(tx, ts) + + if len(ret) == 0 { + panic("no return value specified for CreateBatch") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseRisk) error); ok { + r0 = returnFunc(tx, ts) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_CreateBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBatch' +type LicenseRiskRepository_CreateBatch_Call struct { + *mock.Call +} + +// CreateBatch is a helper method to define mock.On call +// - tx core.DB +// - ts []models.LicenseRisk +func (_e *LicenseRiskRepository_Expecter) CreateBatch(tx interface{}, ts interface{}) *LicenseRiskRepository_CreateBatch_Call { + return &LicenseRiskRepository_CreateBatch_Call{Call: _e.mock.On("CreateBatch", tx, ts)} +} + +func (_c *LicenseRiskRepository_CreateBatch_Call) Run(run func(tx core.DB, ts []models.LicenseRisk)) *LicenseRiskRepository_CreateBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 []models.LicenseRisk + if args[1] != nil { + arg1 = args[1].([]models.LicenseRisk) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_CreateBatch_Call) Return(err error) *LicenseRiskRepository_CreateBatch_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_CreateBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.LicenseRisk) error) *LicenseRiskRepository_CreateBatch_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) Delete(tx core.DB, id string) error { + ret := _mock.Called(tx, id) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(core.DB, string) error); ok { + r0 = returnFunc(tx, id) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type LicenseRiskRepository_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - tx core.DB +// - id string +func (_e *LicenseRiskRepository_Expecter) Delete(tx interface{}, id interface{}) *LicenseRiskRepository_Delete_Call { + return &LicenseRiskRepository_Delete_Call{Call: _e.mock.On("Delete", tx, id)} +} + +func (_c *LicenseRiskRepository_Delete_Call) Run(run func(tx core.DB, id string)) *LicenseRiskRepository_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_Delete_Call) Return(err error) *LicenseRiskRepository_Delete_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_Delete_Call) RunAndReturn(run func(tx core.DB, id string) error) *LicenseRiskRepository_Delete_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBatch provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) DeleteBatch(tx core.DB, ids []models.LicenseRisk) error { + ret := _mock.Called(tx, ids) + + if len(ret) == 0 { + panic("no return value specified for DeleteBatch") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseRisk) error); ok { + r0 = returnFunc(tx, ids) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_DeleteBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBatch' +type LicenseRiskRepository_DeleteBatch_Call struct { + *mock.Call +} + +// DeleteBatch is a helper method to define mock.On call +// - tx core.DB +// - ids []models.LicenseRisk +func (_e *LicenseRiskRepository_Expecter) DeleteBatch(tx interface{}, ids interface{}) *LicenseRiskRepository_DeleteBatch_Call { + return &LicenseRiskRepository_DeleteBatch_Call{Call: _e.mock.On("DeleteBatch", tx, ids)} +} + +func (_c *LicenseRiskRepository_DeleteBatch_Call) Run(run func(tx core.DB, ids []models.LicenseRisk)) *LicenseRiskRepository_DeleteBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 []models.LicenseRisk + if args[1] != nil { + arg1 = args[1].([]models.LicenseRisk) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_DeleteBatch_Call) Return(err error) *LicenseRiskRepository_DeleteBatch_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_DeleteBatch_Call) RunAndReturn(run func(tx core.DB, ids []models.LicenseRisk) error) *LicenseRiskRepository_DeleteBatch_Call { + _c.Call.Return(run) + return _c +} + +// DeleteByComponentPurl provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) DeleteByComponentPurl(assetID uuid.UUID, assetVersionName string, purl packageurl.PackageURL) error { + ret := _mock.Called(assetID, assetVersionName, purl) + + if len(ret) == 0 { + panic("no return value specified for DeleteByComponentPurl") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, string, packageurl.PackageURL) error); ok { + r0 = returnFunc(assetID, assetVersionName, purl) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_DeleteByComponentPurl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByComponentPurl' +type LicenseRiskRepository_DeleteByComponentPurl_Call struct { + *mock.Call +} + +// DeleteByComponentPurl is a helper method to define mock.On call +// - assetID uuid.UUID +// - assetVersionName string +// - purl packageurl.PackageURL +func (_e *LicenseRiskRepository_Expecter) DeleteByComponentPurl(assetID interface{}, assetVersionName interface{}, purl interface{}) *LicenseRiskRepository_DeleteByComponentPurl_Call { + return &LicenseRiskRepository_DeleteByComponentPurl_Call{Call: _e.mock.On("DeleteByComponentPurl", assetID, assetVersionName, purl)} +} + +func (_c *LicenseRiskRepository_DeleteByComponentPurl_Call) Run(run func(assetID uuid.UUID, assetVersionName string, purl packageurl.PackageURL)) *LicenseRiskRepository_DeleteByComponentPurl_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uuid.UUID + if args[0] != nil { + arg0 = args[0].(uuid.UUID) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 packageurl.PackageURL + if args[2] != nil { + arg2 = args[2].(packageurl.PackageURL) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_DeleteByComponentPurl_Call) Return(err error) *LicenseRiskRepository_DeleteByComponentPurl_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_DeleteByComponentPurl_Call) RunAndReturn(run func(assetID uuid.UUID, assetVersionName string, purl packageurl.PackageURL) error) *LicenseRiskRepository_DeleteByComponentPurl_Call { + _c.Call.Return(run) + return _c +} + +// GetAllLicenseRisksForAssetVersion provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) GetAllLicenseRisksForAssetVersion(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error) { + ret := _mock.Called(assetID, assetVersionName) + + if len(ret) == 0 { + panic("no return value specified for GetAllLicenseRisksForAssetVersion") + } + + var r0 []models.LicenseRisk + var r1 error + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, string) ([]models.LicenseRisk, error)); ok { + return returnFunc(assetID, assetVersionName) + } + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, string) []models.LicenseRisk); ok { + r0 = returnFunc(assetID, assetVersionName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]models.LicenseRisk) + } + } + if returnFunc, ok := ret.Get(1).(func(uuid.UUID, string) error); ok { + r1 = returnFunc(assetID, assetVersionName) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllLicenseRisksForAssetVersion' +type LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call struct { + *mock.Call +} + +// GetAllLicenseRisksForAssetVersion is a helper method to define mock.On call +// - assetID uuid.UUID +// - assetVersionName string +func (_e *LicenseRiskRepository_Expecter) GetAllLicenseRisksForAssetVersion(assetID interface{}, assetVersionName interface{}) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call { + return &LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call{Call: _e.mock.On("GetAllLicenseRisksForAssetVersion", assetID, assetVersionName)} +} + +func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call) Run(run func(assetID uuid.UUID, assetVersionName string)) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uuid.UUID + if args[0] != nil { + arg0 = args[0].(uuid.UUID) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call { + _c.Call.Return(licenseRisks, err) + return _c +} + +func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call) RunAndReturn(run func(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error)) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetAllLicenseRisksForAssetVersionPaged provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) GetAllLicenseRisksForAssetVersionPaged(tx core.DB, assetID uuid.UUID, assetVersionName string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.LicenseRisk], error) { + ret := _mock.Called(tx, assetID, assetVersionName, pageInfo, search, filter, sort) + + if len(ret) == 0 { + panic("no return value specified for GetAllLicenseRisksForAssetVersionPaged") + } + + var r0 core.Paged[models.LicenseRisk] + var r1 error + if returnFunc, ok := ret.Get(0).(func(core.DB, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) (core.Paged[models.LicenseRisk], error)); ok { + return returnFunc(tx, assetID, assetVersionName, pageInfo, search, filter, sort) + } + if returnFunc, ok := ret.Get(0).(func(core.DB, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) core.Paged[models.LicenseRisk]); ok { + r0 = returnFunc(tx, assetID, assetVersionName, pageInfo, search, filter, sort) + } else { + r0 = ret.Get(0).(core.Paged[models.LicenseRisk]) + } + if returnFunc, ok := ret.Get(1).(func(core.DB, uuid.UUID, string, core.PageInfo, string, []core.FilterQuery, []core.SortQuery) error); ok { + r1 = returnFunc(tx, assetID, assetVersionName, pageInfo, search, filter, sort) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllLicenseRisksForAssetVersionPaged' +type LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call struct { + *mock.Call +} + +// GetAllLicenseRisksForAssetVersionPaged is a helper method to define mock.On call +// - tx core.DB +// - assetID uuid.UUID +// - assetVersionName string +// - pageInfo core.PageInfo +// - search string +// - filter []core.FilterQuery +// - sort []core.SortQuery +func (_e *LicenseRiskRepository_Expecter) GetAllLicenseRisksForAssetVersionPaged(tx interface{}, assetID interface{}, assetVersionName interface{}, pageInfo interface{}, search interface{}, filter interface{}, sort interface{}) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call { + return &LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call{Call: _e.mock.On("GetAllLicenseRisksForAssetVersionPaged", tx, assetID, assetVersionName, pageInfo, search, filter, sort)} +} + +func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call) Run(run func(tx core.DB, assetID uuid.UUID, assetVersionName string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery)) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 core.PageInfo + if args[3] != nil { + arg3 = args[3].(core.PageInfo) + } + var arg4 string + if args[4] != nil { + arg4 = args[4].(string) + } + var arg5 []core.FilterQuery + if args[5] != nil { + arg5 = args[5].([]core.FilterQuery) + } + var arg6 []core.SortQuery + if args[6] != nil { + arg6 = args[6].([]core.SortQuery) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call) Return(paged core.Paged[models.LicenseRisk], err error) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call { + _c.Call.Return(paged, err) + return _c +} + +func (_c *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call) RunAndReturn(run func(tx core.DB, assetID uuid.UUID, assetVersionName string, pageInfo core.PageInfo, search string, filter []core.FilterQuery, sort []core.SortQuery) (core.Paged[models.LicenseRisk], error)) *LicenseRiskRepository_GetAllLicenseRisksForAssetVersionPaged_Call { + _c.Call.Return(run) + return _c +} + +// GetAllOverwrittenLicensesForAssetVersion provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) GetAllOverwrittenLicensesForAssetVersion(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error) { + ret := _mock.Called(assetID, assetVersionName) + + if len(ret) == 0 { + panic("no return value specified for GetAllOverwrittenLicensesForAssetVersion") + } + + var r0 []models.LicenseRisk + var r1 error + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, string) ([]models.LicenseRisk, error)); ok { + return returnFunc(assetID, assetVersionName) + } + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, string) []models.LicenseRisk); ok { + r0 = returnFunc(assetID, assetVersionName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]models.LicenseRisk) + } + } + if returnFunc, ok := ret.Get(1).(func(uuid.UUID, string) error); ok { + r1 = returnFunc(assetID, assetVersionName) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllOverwrittenLicensesForAssetVersion' +type LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call struct { + *mock.Call +} + +// GetAllOverwrittenLicensesForAssetVersion is a helper method to define mock.On call +// - assetID uuid.UUID +// - assetVersionName string +func (_e *LicenseRiskRepository_Expecter) GetAllOverwrittenLicensesForAssetVersion(assetID interface{}, assetVersionName interface{}) *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call { + return &LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call{Call: _e.mock.On("GetAllOverwrittenLicensesForAssetVersion", assetID, assetVersionName)} +} + +func (_c *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call) Run(run func(assetID uuid.UUID, assetVersionName string)) *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uuid.UUID + if args[0] != nil { + arg0 = args[0].(uuid.UUID) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call { + _c.Call.Return(licenseRisks, err) + return _c +} + +func (_c *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call) RunAndReturn(run func(assetID uuid.UUID, assetVersionName string) ([]models.LicenseRisk, error)) *LicenseRiskRepository_GetAllOverwrittenLicensesForAssetVersion_Call { + _c.Call.Return(run) + return _c +} + +// GetDB provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) GetDB(tx core.DB) core.DB { + ret := _mock.Called(tx) + + if len(ret) == 0 { + panic("no return value specified for GetDB") + } + + var r0 core.DB + if returnFunc, ok := ret.Get(0).(func(core.DB) core.DB); ok { + r0 = returnFunc(tx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.DB) + } + } + return r0 +} + +// LicenseRiskRepository_GetDB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDB' +type LicenseRiskRepository_GetDB_Call struct { + *mock.Call +} + +// GetDB is a helper method to define mock.On call +// - tx core.DB +func (_e *LicenseRiskRepository_Expecter) GetDB(tx interface{}) *LicenseRiskRepository_GetDB_Call { + return &LicenseRiskRepository_GetDB_Call{Call: _e.mock.On("GetDB", tx)} +} + +func (_c *LicenseRiskRepository_GetDB_Call) Run(run func(tx core.DB)) *LicenseRiskRepository_GetDB_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_GetDB_Call) Return(v core.DB) *LicenseRiskRepository_GetDB_Call { + _c.Call.Return(v) + return _c +} + +func (_c *LicenseRiskRepository_GetDB_Call) RunAndReturn(run func(tx core.DB) core.DB) *LicenseRiskRepository_GetDB_Call { + _c.Call.Return(run) + return _c +} + +// List provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) List(ids []string) ([]models.LicenseRisk, error) { + ret := _mock.Called(ids) + + if len(ret) == 0 { + panic("no return value specified for List") + } + + var r0 []models.LicenseRisk + var r1 error + if returnFunc, ok := ret.Get(0).(func([]string) ([]models.LicenseRisk, error)); ok { + return returnFunc(ids) + } + if returnFunc, ok := ret.Get(0).(func([]string) []models.LicenseRisk); ok { + r0 = returnFunc(ids) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]models.LicenseRisk) + } + } + if returnFunc, ok := ret.Get(1).(func([]string) error); ok { + r1 = returnFunc(ids) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskRepository_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type LicenseRiskRepository_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ids []string +func (_e *LicenseRiskRepository_Expecter) List(ids interface{}) *LicenseRiskRepository_List_Call { + return &LicenseRiskRepository_List_Call{Call: _e.mock.On("List", ids)} +} + +func (_c *LicenseRiskRepository_List_Call) Run(run func(ids []string)) *LicenseRiskRepository_List_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []string + if args[0] != nil { + arg0 = args[0].([]string) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_List_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_List_Call { + _c.Call.Return(licenseRisks, err) + return _c +} + +func (_c *LicenseRiskRepository_List_Call) RunAndReturn(run func(ids []string) ([]models.LicenseRisk, error)) *LicenseRiskRepository_List_Call { + _c.Call.Return(run) + return _c +} + +// ListByScanner provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) ListByScanner(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.LicenseRisk, error) { + ret := _mock.Called(assetVersionName, assetID, scannerID) + + if len(ret) == 0 { + panic("no return value specified for ListByScanner") + } + + var r0 []models.LicenseRisk + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, string) ([]models.LicenseRisk, error)); ok { + return returnFunc(assetVersionName, assetID, scannerID) + } + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, string) []models.LicenseRisk); ok { + r0 = returnFunc(assetVersionName, assetID, scannerID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]models.LicenseRisk) + } + } + if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID, string) error); ok { + r1 = returnFunc(assetVersionName, assetID, scannerID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskRepository_ListByScanner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListByScanner' +type LicenseRiskRepository_ListByScanner_Call struct { + *mock.Call +} + +// ListByScanner is a helper method to define mock.On call +// - assetVersionName string +// - assetID uuid.UUID +// - scannerID string +func (_e *LicenseRiskRepository_Expecter) ListByScanner(assetVersionName interface{}, assetID interface{}, scannerID interface{}) *LicenseRiskRepository_ListByScanner_Call { + return &LicenseRiskRepository_ListByScanner_Call{Call: _e.mock.On("ListByScanner", assetVersionName, assetID, scannerID)} +} + +func (_c *LicenseRiskRepository_ListByScanner_Call) Run(run func(assetVersionName string, assetID uuid.UUID, scannerID string)) *LicenseRiskRepository_ListByScanner_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_ListByScanner_Call) Return(licenseRisks []models.LicenseRisk, err error) *LicenseRiskRepository_ListByScanner_Call { + _c.Call.Return(licenseRisks, err) + return _c +} + +func (_c *LicenseRiskRepository_ListByScanner_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID, scannerID string) ([]models.LicenseRisk, error)) *LicenseRiskRepository_ListByScanner_Call { + _c.Call.Return(run) + return _c +} + +// MaybeGetLicenseOverwriteForComponent provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) MaybeGetLicenseOverwriteForComponent(assetID uuid.UUID, assetVersionName string, pURL packageurl.PackageURL) (models.LicenseRisk, error) { + ret := _mock.Called(assetID, assetVersionName, pURL) + + if len(ret) == 0 { + panic("no return value specified for MaybeGetLicenseOverwriteForComponent") + } + + var r0 models.LicenseRisk + var r1 error + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, string, packageurl.PackageURL) (models.LicenseRisk, error)); ok { + return returnFunc(assetID, assetVersionName, pURL) + } + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, string, packageurl.PackageURL) models.LicenseRisk); ok { + r0 = returnFunc(assetID, assetVersionName, pURL) + } else { + r0 = ret.Get(0).(models.LicenseRisk) + } + if returnFunc, ok := ret.Get(1).(func(uuid.UUID, string, packageurl.PackageURL) error); ok { + r1 = returnFunc(assetID, assetVersionName, pURL) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MaybeGetLicenseOverwriteForComponent' +type LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call struct { + *mock.Call +} + +// MaybeGetLicenseOverwriteForComponent is a helper method to define mock.On call +// - assetID uuid.UUID +// - assetVersionName string +// - pURL packageurl.PackageURL +func (_e *LicenseRiskRepository_Expecter) MaybeGetLicenseOverwriteForComponent(assetID interface{}, assetVersionName interface{}, pURL interface{}) *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call { + return &LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call{Call: _e.mock.On("MaybeGetLicenseOverwriteForComponent", assetID, assetVersionName, pURL)} +} + +func (_c *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call) Run(run func(assetID uuid.UUID, assetVersionName string, pURL packageurl.PackageURL)) *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uuid.UUID + if args[0] != nil { + arg0 = args[0].(uuid.UUID) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 packageurl.PackageURL + if args[2] != nil { + arg2 = args[2].(packageurl.PackageURL) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call) Return(licenseRisk models.LicenseRisk, err error) *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call { + _c.Call.Return(licenseRisk, err) + return _c +} + +func (_c *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call) RunAndReturn(run func(assetID uuid.UUID, assetVersionName string, pURL packageurl.PackageURL) (models.LicenseRisk, error)) *LicenseRiskRepository_MaybeGetLicenseOverwriteForComponent_Call { + _c.Call.Return(run) + return _c +} + +// Read provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) Read(id string) (models.LicenseRisk, error) { + ret := _mock.Called(id) + + if len(ret) == 0 { + panic("no return value specified for Read") + } + + var r0 models.LicenseRisk + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) (models.LicenseRisk, error)); ok { + return returnFunc(id) + } + if returnFunc, ok := ret.Get(0).(func(string) models.LicenseRisk); ok { + r0 = returnFunc(id) + } else { + r0 = ret.Get(0).(models.LicenseRisk) + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(id) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskRepository_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type LicenseRiskRepository_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - id string +func (_e *LicenseRiskRepository_Expecter) Read(id interface{}) *LicenseRiskRepository_Read_Call { + return &LicenseRiskRepository_Read_Call{Call: _e.mock.On("Read", id)} +} + +func (_c *LicenseRiskRepository_Read_Call) Run(run func(id string)) *LicenseRiskRepository_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_Read_Call) Return(licenseRisk models.LicenseRisk, err error) *LicenseRiskRepository_Read_Call { + _c.Call.Return(licenseRisk, err) + return _c +} + +func (_c *LicenseRiskRepository_Read_Call) RunAndReturn(run func(id string) (models.LicenseRisk, error)) *LicenseRiskRepository_Read_Call { + _c.Call.Return(run) + return _c +} + +// Save provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) Save(tx core.DB, t *models.LicenseRisk) error { + ret := _mock.Called(tx, t) + + if len(ret) == 0 { + panic("no return value specified for Save") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(core.DB, *models.LicenseRisk) error); ok { + r0 = returnFunc(tx, t) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save' +type LicenseRiskRepository_Save_Call struct { + *mock.Call +} + +// Save is a helper method to define mock.On call +// - tx core.DB +// - t *models.LicenseRisk +func (_e *LicenseRiskRepository_Expecter) Save(tx interface{}, t interface{}) *LicenseRiskRepository_Save_Call { + return &LicenseRiskRepository_Save_Call{Call: _e.mock.On("Save", tx, t)} +} + +func (_c *LicenseRiskRepository_Save_Call) Run(run func(tx core.DB, t *models.LicenseRisk)) *LicenseRiskRepository_Save_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 *models.LicenseRisk + if args[1] != nil { + arg1 = args[1].(*models.LicenseRisk) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_Save_Call) Return(err error) *LicenseRiskRepository_Save_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_Save_Call) RunAndReturn(run func(tx core.DB, t *models.LicenseRisk) error) *LicenseRiskRepository_Save_Call { + _c.Call.Return(run) + return _c +} + +// SaveBatch provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) SaveBatch(tx core.DB, ts []models.LicenseRisk) error { + ret := _mock.Called(tx, ts) + + if len(ret) == 0 { + panic("no return value specified for SaveBatch") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(core.DB, []models.LicenseRisk) error); ok { + r0 = returnFunc(tx, ts) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_SaveBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveBatch' +type LicenseRiskRepository_SaveBatch_Call struct { + *mock.Call +} + +// SaveBatch is a helper method to define mock.On call +// - tx core.DB +// - ts []models.LicenseRisk +func (_e *LicenseRiskRepository_Expecter) SaveBatch(tx interface{}, ts interface{}) *LicenseRiskRepository_SaveBatch_Call { + return &LicenseRiskRepository_SaveBatch_Call{Call: _e.mock.On("SaveBatch", tx, ts)} +} + +func (_c *LicenseRiskRepository_SaveBatch_Call) Run(run func(tx core.DB, ts []models.LicenseRisk)) *LicenseRiskRepository_SaveBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 []models.LicenseRisk + if args[1] != nil { + arg1 = args[1].([]models.LicenseRisk) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_SaveBatch_Call) Return(err error) *LicenseRiskRepository_SaveBatch_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_SaveBatch_Call) RunAndReturn(run func(tx core.DB, ts []models.LicenseRisk) error) *LicenseRiskRepository_SaveBatch_Call { + _c.Call.Return(run) + return _c +} + +// Transaction provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) Transaction(fn func(tx core.DB) error) error { + ret := _mock.Called(fn) + + if len(ret) == 0 { + panic("no return value specified for Transaction") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(func(tx core.DB) error) error); ok { + r0 = returnFunc(fn) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_Transaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Transaction' +type LicenseRiskRepository_Transaction_Call struct { + *mock.Call +} + +// Transaction is a helper method to define mock.On call +// - fn func(tx core.DB) error +func (_e *LicenseRiskRepository_Expecter) Transaction(fn interface{}) *LicenseRiskRepository_Transaction_Call { + return &LicenseRiskRepository_Transaction_Call{Call: _e.mock.On("Transaction", fn)} +} + +func (_c *LicenseRiskRepository_Transaction_Call) Run(run func(fn func(tx core.DB) error)) *LicenseRiskRepository_Transaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 func(tx core.DB) error + if args[0] != nil { + arg0 = args[0].(func(tx core.DB) error) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_Transaction_Call) Return(err error) *LicenseRiskRepository_Transaction_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_Transaction_Call) RunAndReturn(run func(fn func(tx core.DB) error) error) *LicenseRiskRepository_Transaction_Call { + _c.Call.Return(run) + return _c +} + +// Upsert provides a mock function for the type LicenseRiskRepository +func (_mock *LicenseRiskRepository) Upsert(t *[]*models.LicenseRisk, conflictingColumns []clause.Column, updateOnly []string) error { + ret := _mock.Called(t, conflictingColumns, updateOnly) + + if len(ret) == 0 { + panic("no return value specified for Upsert") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(*[]*models.LicenseRisk, []clause.Column, []string) error); ok { + r0 = returnFunc(t, conflictingColumns, updateOnly) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskRepository_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert' +type LicenseRiskRepository_Upsert_Call struct { + *mock.Call +} + +// Upsert is a helper method to define mock.On call +// - t *[]*models.LicenseRisk +// - conflictingColumns []clause.Column +// - updateOnly []string +func (_e *LicenseRiskRepository_Expecter) Upsert(t interface{}, conflictingColumns interface{}, updateOnly interface{}) *LicenseRiskRepository_Upsert_Call { + return &LicenseRiskRepository_Upsert_Call{Call: _e.mock.On("Upsert", t, conflictingColumns, updateOnly)} +} + +func (_c *LicenseRiskRepository_Upsert_Call) Run(run func(t *[]*models.LicenseRisk, conflictingColumns []clause.Column, updateOnly []string)) *LicenseRiskRepository_Upsert_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *[]*models.LicenseRisk + if args[0] != nil { + arg0 = args[0].(*[]*models.LicenseRisk) + } + var arg1 []clause.Column + if args[1] != nil { + arg1 = args[1].([]clause.Column) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *LicenseRiskRepository_Upsert_Call) Return(err error) *LicenseRiskRepository_Upsert_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskRepository_Upsert_Call) RunAndReturn(run func(t *[]*models.LicenseRisk, conflictingColumns []clause.Column, updateOnly []string) error) *LicenseRiskRepository_Upsert_Call { + _c.Call.Return(run) + return _c +} diff --git a/mocks/mock_LicenseRiskService.go b/mocks/mock_LicenseRiskService.go new file mode 100644 index 000000000..fa5e74a0e --- /dev/null +++ b/mocks/mock_LicenseRiskService.go @@ -0,0 +1,254 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "github.com/l3montree-dev/devguard/internal/core" + "github.com/l3montree-dev/devguard/internal/database/models" + mock "github.com/stretchr/testify/mock" +) + +// NewLicenseRiskService creates a new instance of LicenseRiskService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewLicenseRiskService(t interface { + mock.TestingT + Cleanup(func()) +}) *LicenseRiskService { + mock := &LicenseRiskService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// LicenseRiskService is an autogenerated mock type for the LicenseRiskService type +type LicenseRiskService struct { + mock.Mock +} + +type LicenseRiskService_Expecter struct { + mock *mock.Mock +} + +func (_m *LicenseRiskService) EXPECT() *LicenseRiskService_Expecter { + return &LicenseRiskService_Expecter{mock: &_m.Mock} +} + +// FindLicenseRisksInComponents provides a mock function for the type LicenseRiskService +func (_mock *LicenseRiskService) FindLicenseRisksInComponents(assetVersion models.AssetVersion, components []models.Component, scannerID string) error { + ret := _mock.Called(assetVersion, components, scannerID) + + if len(ret) == 0 { + panic("no return value specified for FindLicenseRisksInComponents") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(models.AssetVersion, []models.Component, string) error); ok { + r0 = returnFunc(assetVersion, components, scannerID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskService_FindLicenseRisksInComponents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindLicenseRisksInComponents' +type LicenseRiskService_FindLicenseRisksInComponents_Call struct { + *mock.Call +} + +// FindLicenseRisksInComponents is a helper method to define mock.On call +// - assetVersion models.AssetVersion +// - components []models.Component +// - scannerID string +func (_e *LicenseRiskService_Expecter) FindLicenseRisksInComponents(assetVersion interface{}, components interface{}, scannerID interface{}) *LicenseRiskService_FindLicenseRisksInComponents_Call { + return &LicenseRiskService_FindLicenseRisksInComponents_Call{Call: _e.mock.On("FindLicenseRisksInComponents", assetVersion, components, scannerID)} +} + +func (_c *LicenseRiskService_FindLicenseRisksInComponents_Call) Run(run func(assetVersion models.AssetVersion, components []models.Component, scannerID string)) *LicenseRiskService_FindLicenseRisksInComponents_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 models.AssetVersion + if args[0] != nil { + arg0 = args[0].(models.AssetVersion) + } + var arg1 []models.Component + if args[1] != nil { + arg1 = args[1].([]models.Component) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *LicenseRiskService_FindLicenseRisksInComponents_Call) Return(err error) *LicenseRiskService_FindLicenseRisksInComponents_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskService_FindLicenseRisksInComponents_Call) RunAndReturn(run func(assetVersion models.AssetVersion, components []models.Component, scannerID string) error) *LicenseRiskService_FindLicenseRisksInComponents_Call { + _c.Call.Return(run) + return _c +} + +// MakeFinalLicenseDecision provides a mock function for the type LicenseRiskService +func (_mock *LicenseRiskService) MakeFinalLicenseDecision(vulnID string, finalLicense string, userID string) error { + ret := _mock.Called(vulnID, finalLicense, userID) + + if len(ret) == 0 { + panic("no return value specified for MakeFinalLicenseDecision") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(string, string, string) error); ok { + r0 = returnFunc(vulnID, finalLicense, userID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// LicenseRiskService_MakeFinalLicenseDecision_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MakeFinalLicenseDecision' +type LicenseRiskService_MakeFinalLicenseDecision_Call struct { + *mock.Call +} + +// MakeFinalLicenseDecision is a helper method to define mock.On call +// - vulnID string +// - finalLicense string +// - userID string +func (_e *LicenseRiskService_Expecter) MakeFinalLicenseDecision(vulnID interface{}, finalLicense interface{}, userID interface{}) *LicenseRiskService_MakeFinalLicenseDecision_Call { + return &LicenseRiskService_MakeFinalLicenseDecision_Call{Call: _e.mock.On("MakeFinalLicenseDecision", vulnID, finalLicense, userID)} +} + +func (_c *LicenseRiskService_MakeFinalLicenseDecision_Call) Run(run func(vulnID string, finalLicense string, userID string)) *LicenseRiskService_MakeFinalLicenseDecision_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *LicenseRiskService_MakeFinalLicenseDecision_Call) Return(err error) *LicenseRiskService_MakeFinalLicenseDecision_Call { + _c.Call.Return(err) + return _c +} + +func (_c *LicenseRiskService_MakeFinalLicenseDecision_Call) RunAndReturn(run func(vulnID string, finalLicense string, userID string) error) *LicenseRiskService_MakeFinalLicenseDecision_Call { + _c.Call.Return(run) + return _c +} + +// UpdateLicenseRiskState provides a mock function for the type LicenseRiskService +func (_mock *LicenseRiskService) UpdateLicenseRiskState(tx core.DB, userID string, licenseRisk *models.LicenseRisk, statusType string, justification string, mechanicalJustification models.MechanicalJustificationType) (models.VulnEvent, error) { + ret := _mock.Called(tx, userID, licenseRisk, statusType, justification, mechanicalJustification) + + if len(ret) == 0 { + panic("no return value specified for UpdateLicenseRiskState") + } + + var r0 models.VulnEvent + var r1 error + if returnFunc, ok := ret.Get(0).(func(core.DB, string, *models.LicenseRisk, string, string, models.MechanicalJustificationType) (models.VulnEvent, error)); ok { + return returnFunc(tx, userID, licenseRisk, statusType, justification, mechanicalJustification) + } + if returnFunc, ok := ret.Get(0).(func(core.DB, string, *models.LicenseRisk, string, string, models.MechanicalJustificationType) models.VulnEvent); ok { + r0 = returnFunc(tx, userID, licenseRisk, statusType, justification, mechanicalJustification) + } else { + r0 = ret.Get(0).(models.VulnEvent) + } + if returnFunc, ok := ret.Get(1).(func(core.DB, string, *models.LicenseRisk, string, string, models.MechanicalJustificationType) error); ok { + r1 = returnFunc(tx, userID, licenseRisk, statusType, justification, mechanicalJustification) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// LicenseRiskService_UpdateLicenseRiskState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLicenseRiskState' +type LicenseRiskService_UpdateLicenseRiskState_Call struct { + *mock.Call +} + +// UpdateLicenseRiskState is a helper method to define mock.On call +// - tx core.DB +// - userID string +// - licenseRisk *models.LicenseRisk +// - statusType string +// - justification string +// - mechanicalJustification models.MechanicalJustificationType +func (_e *LicenseRiskService_Expecter) UpdateLicenseRiskState(tx interface{}, userID interface{}, licenseRisk interface{}, statusType interface{}, justification interface{}, mechanicalJustification interface{}) *LicenseRiskService_UpdateLicenseRiskState_Call { + return &LicenseRiskService_UpdateLicenseRiskState_Call{Call: _e.mock.On("UpdateLicenseRiskState", tx, userID, licenseRisk, statusType, justification, mechanicalJustification)} +} + +func (_c *LicenseRiskService_UpdateLicenseRiskState_Call) Run(run func(tx core.DB, userID string, licenseRisk *models.LicenseRisk, statusType string, justification string, mechanicalJustification models.MechanicalJustificationType)) *LicenseRiskService_UpdateLicenseRiskState_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 core.DB + if args[0] != nil { + arg0 = args[0].(core.DB) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 *models.LicenseRisk + if args[2] != nil { + arg2 = args[2].(*models.LicenseRisk) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 string + if args[4] != nil { + arg4 = args[4].(string) + } + var arg5 models.MechanicalJustificationType + if args[5] != nil { + arg5 = args[5].(models.MechanicalJustificationType) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + ) + }) + return _c +} + +func (_c *LicenseRiskService_UpdateLicenseRiskState_Call) Return(vulnEvent models.VulnEvent, err error) *LicenseRiskService_UpdateLicenseRiskState_Call { + _c.Call.Return(vulnEvent, err) + return _c +} + +func (_c *LicenseRiskService_UpdateLicenseRiskState_Call) RunAndReturn(run func(tx core.DB, userID string, licenseRisk *models.LicenseRisk, statusType string, justification string, mechanicalJustification models.MechanicalJustificationType) (models.VulnEvent, error)) *LicenseRiskService_UpdateLicenseRiskState_Call { + _c.Call.Return(run) + return _c +} diff --git a/mocks/mock_StatisticsService.go b/mocks/mock_StatisticsService.go index ef36da79d..4c909cd8b 100644 --- a/mocks/mock_StatisticsService.go +++ b/mocks/mock_StatisticsService.go @@ -8,6 +8,7 @@ import ( "time" "github.com/google/uuid" + "github.com/l3montree-dev/devguard/internal/core/statistics" "github.com/l3montree-dev/devguard/internal/database/models" mock "github.com/stretchr/testify/mock" ) @@ -26,7 +27,7 @@ func NewStatisticsService(t interface { return mock } -// StatisticsService is an autogenerated mock type for the StatisticsService type +// StatisticsService is an autogenerated mock type for the statisticsService type type StatisticsService struct { mock.Mock } @@ -111,9 +112,583 @@ func (_c *StatisticsService_GetAssetVersionCvssDistribution_Call) RunAndReturn(r return _c } +// GetAssetVersionRiskDistribution provides a mock function for the type StatisticsService +func (_mock *StatisticsService) GetAssetVersionRiskDistribution(assetVersionName string, assetID uuid.UUID, assetName string) (models.AssetRiskDistribution, error) { + ret := _mock.Called(assetVersionName, assetID, assetName) + + if len(ret) == 0 { + panic("no return value specified for GetAssetVersionRiskDistribution") + } + + var r0 models.AssetRiskDistribution + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, string) (models.AssetRiskDistribution, error)); ok { + return returnFunc(assetVersionName, assetID, assetName) + } + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, string) models.AssetRiskDistribution); ok { + r0 = returnFunc(assetVersionName, assetID, assetName) + } else { + r0 = ret.Get(0).(models.AssetRiskDistribution) + } + if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID, string) error); ok { + r1 = returnFunc(assetVersionName, assetID, assetName) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// StatisticsService_GetAssetVersionRiskDistribution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAssetVersionRiskDistribution' +type StatisticsService_GetAssetVersionRiskDistribution_Call struct { + *mock.Call +} + +// GetAssetVersionRiskDistribution is a helper method to define mock.On call +// - assetVersionName string +// - assetID uuid.UUID +// - assetName string +func (_e *StatisticsService_Expecter) GetAssetVersionRiskDistribution(assetVersionName interface{}, assetID interface{}, assetName interface{}) *StatisticsService_GetAssetVersionRiskDistribution_Call { + return &StatisticsService_GetAssetVersionRiskDistribution_Call{Call: _e.mock.On("GetAssetVersionRiskDistribution", assetVersionName, assetID, assetName)} +} + +func (_c *StatisticsService_GetAssetVersionRiskDistribution_Call) Run(run func(assetVersionName string, assetID uuid.UUID, assetName string)) *StatisticsService_GetAssetVersionRiskDistribution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *StatisticsService_GetAssetVersionRiskDistribution_Call) Return(assetRiskDistribution models.AssetRiskDistribution, err error) *StatisticsService_GetAssetVersionRiskDistribution_Call { + _c.Call.Return(assetRiskDistribution, err) + return _c +} + +func (_c *StatisticsService_GetAssetVersionRiskDistribution_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID, assetName string) (models.AssetRiskDistribution, error)) *StatisticsService_GetAssetVersionRiskDistribution_Call { + _c.Call.Return(run) + return _c +} + +// GetAssetVersionRiskHistory provides a mock function for the type StatisticsService +func (_mock *StatisticsService) GetAssetVersionRiskHistory(assetVersionName string, assetID uuid.UUID, start time.Time, end time.Time) ([]models.AssetRiskHistory, error) { + ret := _mock.Called(assetVersionName, assetID, start, end) + + if len(ret) == 0 { + panic("no return value specified for GetAssetVersionRiskHistory") + } + + var r0 []models.AssetRiskHistory + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, time.Time, time.Time) ([]models.AssetRiskHistory, error)); ok { + return returnFunc(assetVersionName, assetID, start, end) + } + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, time.Time, time.Time) []models.AssetRiskHistory); ok { + r0 = returnFunc(assetVersionName, assetID, start, end) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]models.AssetRiskHistory) + } + } + if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID, time.Time, time.Time) error); ok { + r1 = returnFunc(assetVersionName, assetID, start, end) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// StatisticsService_GetAssetVersionRiskHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAssetVersionRiskHistory' +type StatisticsService_GetAssetVersionRiskHistory_Call struct { + *mock.Call +} + +// GetAssetVersionRiskHistory is a helper method to define mock.On call +// - assetVersionName string +// - assetID uuid.UUID +// - start time.Time +// - end time.Time +func (_e *StatisticsService_Expecter) GetAssetVersionRiskHistory(assetVersionName interface{}, assetID interface{}, start interface{}, end interface{}) *StatisticsService_GetAssetVersionRiskHistory_Call { + return &StatisticsService_GetAssetVersionRiskHistory_Call{Call: _e.mock.On("GetAssetVersionRiskHistory", assetVersionName, assetID, start, end)} +} + +func (_c *StatisticsService_GetAssetVersionRiskHistory_Call) Run(run func(assetVersionName string, assetID uuid.UUID, start time.Time, end time.Time)) *StatisticsService_GetAssetVersionRiskHistory_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 time.Time + if args[2] != nil { + arg2 = args[2].(time.Time) + } + var arg3 time.Time + if args[3] != nil { + arg3 = args[3].(time.Time) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *StatisticsService_GetAssetVersionRiskHistory_Call) Return(assetRiskHistorys []models.AssetRiskHistory, err error) *StatisticsService_GetAssetVersionRiskHistory_Call { + _c.Call.Return(assetRiskHistorys, err) + return _c +} + +func (_c *StatisticsService_GetAssetVersionRiskHistory_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID, start time.Time, end time.Time) ([]models.AssetRiskHistory, error)) *StatisticsService_GetAssetVersionRiskHistory_Call { + _c.Call.Return(run) + return _c +} + +// GetAverageFixingTime provides a mock function for the type StatisticsService +func (_mock *StatisticsService) GetAverageFixingTime(assetVersionName string, assetID uuid.UUID, severity string) (time.Duration, error) { + ret := _mock.Called(assetVersionName, assetID, severity) + + if len(ret) == 0 { + panic("no return value specified for GetAverageFixingTime") + } + + var r0 time.Duration + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, string) (time.Duration, error)); ok { + return returnFunc(assetVersionName, assetID, severity) + } + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, string) time.Duration); ok { + r0 = returnFunc(assetVersionName, assetID, severity) + } else { + r0 = ret.Get(0).(time.Duration) + } + if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID, string) error); ok { + r1 = returnFunc(assetVersionName, assetID, severity) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// StatisticsService_GetAverageFixingTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAverageFixingTime' +type StatisticsService_GetAverageFixingTime_Call struct { + *mock.Call +} + +// GetAverageFixingTime is a helper method to define mock.On call +// - assetVersionName string +// - assetID uuid.UUID +// - severity string +func (_e *StatisticsService_Expecter) GetAverageFixingTime(assetVersionName interface{}, assetID interface{}, severity interface{}) *StatisticsService_GetAverageFixingTime_Call { + return &StatisticsService_GetAverageFixingTime_Call{Call: _e.mock.On("GetAverageFixingTime", assetVersionName, assetID, severity)} +} + +func (_c *StatisticsService_GetAverageFixingTime_Call) Run(run func(assetVersionName string, assetID uuid.UUID, severity string)) *StatisticsService_GetAverageFixingTime_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *StatisticsService_GetAverageFixingTime_Call) Return(duration time.Duration, err error) *StatisticsService_GetAverageFixingTime_Call { + _c.Call.Return(duration, err) + return _c +} + +func (_c *StatisticsService_GetAverageFixingTime_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID, severity string) (time.Duration, error)) *StatisticsService_GetAverageFixingTime_Call { + _c.Call.Return(run) + return _c +} + +// GetComponentRisk provides a mock function for the type StatisticsService +func (_mock *StatisticsService) GetComponentRisk(assetVersionName string, assetID uuid.UUID) (map[string]float64, error) { + ret := _mock.Called(assetVersionName, assetID) + + if len(ret) == 0 { + panic("no return value specified for GetComponentRisk") + } + + var r0 map[string]float64 + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID) (map[string]float64, error)); ok { + return returnFunc(assetVersionName, assetID) + } + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID) map[string]float64); ok { + r0 = returnFunc(assetVersionName, assetID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]float64) + } + } + if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID) error); ok { + r1 = returnFunc(assetVersionName, assetID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// StatisticsService_GetComponentRisk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComponentRisk' +type StatisticsService_GetComponentRisk_Call struct { + *mock.Call +} + +// GetComponentRisk is a helper method to define mock.On call +// - assetVersionName string +// - assetID uuid.UUID +func (_e *StatisticsService_Expecter) GetComponentRisk(assetVersionName interface{}, assetID interface{}) *StatisticsService_GetComponentRisk_Call { + return &StatisticsService_GetComponentRisk_Call{Call: _e.mock.On("GetComponentRisk", assetVersionName, assetID)} +} + +func (_c *StatisticsService_GetComponentRisk_Call) Run(run func(assetVersionName string, assetID uuid.UUID)) *StatisticsService_GetComponentRisk_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *StatisticsService_GetComponentRisk_Call) Return(stringToFloat64 map[string]float64, err error) *StatisticsService_GetComponentRisk_Call { + _c.Call.Return(stringToFloat64, err) + return _c +} + +func (_c *StatisticsService_GetComponentRisk_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID) (map[string]float64, error)) *StatisticsService_GetComponentRisk_Call { + _c.Call.Return(run) + return _c +} + +// GetDependencyCountPerscanner provides a mock function for the type StatisticsService +func (_mock *StatisticsService) GetDependencyCountPerscanner(assetVersionName string, assetID uuid.UUID) (map[string]int, error) { + ret := _mock.Called(assetVersionName, assetID) + + if len(ret) == 0 { + panic("no return value specified for GetDependencyCountPerscanner") + } + + var r0 map[string]int + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID) (map[string]int, error)); ok { + return returnFunc(assetVersionName, assetID) + } + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID) map[string]int); ok { + r0 = returnFunc(assetVersionName, assetID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]int) + } + } + if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID) error); ok { + r1 = returnFunc(assetVersionName, assetID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// StatisticsService_GetDependencyCountPerscanner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencyCountPerscanner' +type StatisticsService_GetDependencyCountPerscanner_Call struct { + *mock.Call +} + +// GetDependencyCountPerscanner is a helper method to define mock.On call +// - assetVersionName string +// - assetID uuid.UUID +func (_e *StatisticsService_Expecter) GetDependencyCountPerscanner(assetVersionName interface{}, assetID interface{}) *StatisticsService_GetDependencyCountPerscanner_Call { + return &StatisticsService_GetDependencyCountPerscanner_Call{Call: _e.mock.On("GetDependencyCountPerscanner", assetVersionName, assetID)} +} + +func (_c *StatisticsService_GetDependencyCountPerscanner_Call) Run(run func(assetVersionName string, assetID uuid.UUID)) *StatisticsService_GetDependencyCountPerscanner_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *StatisticsService_GetDependencyCountPerscanner_Call) Return(stringToInt map[string]int, err error) *StatisticsService_GetDependencyCountPerscanner_Call { + _c.Call.Return(stringToInt, err) + return _c +} + +func (_c *StatisticsService_GetDependencyCountPerscanner_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID) (map[string]int, error)) *StatisticsService_GetDependencyCountPerscanner_Call { + _c.Call.Return(run) + return _c +} + +// GetDependencyVulnAggregationStateAndChangeSince provides a mock function for the type StatisticsService +func (_mock *StatisticsService) GetDependencyVulnAggregationStateAndChangeSince(assetVersionName string, assetID uuid.UUID, calculateChangeTo time.Time) (statistics.DependencyVulnAggregationStateAndChange, error) { + ret := _mock.Called(assetVersionName, assetID, calculateChangeTo) + + if len(ret) == 0 { + panic("no return value specified for GetDependencyVulnAggregationStateAndChangeSince") + } + + var r0 statistics.DependencyVulnAggregationStateAndChange + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, time.Time) (statistics.DependencyVulnAggregationStateAndChange, error)); ok { + return returnFunc(assetVersionName, assetID, calculateChangeTo) + } + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID, time.Time) statistics.DependencyVulnAggregationStateAndChange); ok { + r0 = returnFunc(assetVersionName, assetID, calculateChangeTo) + } else { + r0 = ret.Get(0).(statistics.DependencyVulnAggregationStateAndChange) + } + if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID, time.Time) error); ok { + r1 = returnFunc(assetVersionName, assetID, calculateChangeTo) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencyVulnAggregationStateAndChangeSince' +type StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call struct { + *mock.Call +} + +// GetDependencyVulnAggregationStateAndChangeSince is a helper method to define mock.On call +// - assetVersionName string +// - assetID uuid.UUID +// - calculateChangeTo time.Time +func (_e *StatisticsService_Expecter) GetDependencyVulnAggregationStateAndChangeSince(assetVersionName interface{}, assetID interface{}, calculateChangeTo interface{}) *StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call { + return &StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call{Call: _e.mock.On("GetDependencyVulnAggregationStateAndChangeSince", assetVersionName, assetID, calculateChangeTo)} +} + +func (_c *StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call) Run(run func(assetVersionName string, assetID uuid.UUID, calculateChangeTo time.Time)) *StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + var arg2 time.Time + if args[2] != nil { + arg2 = args[2].(time.Time) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call) Return(dependencyVulnAggregationStateAndChange statistics.DependencyVulnAggregationStateAndChange, err error) *StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call { + _c.Call.Return(dependencyVulnAggregationStateAndChange, err) + return _c +} + +func (_c *StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID, calculateChangeTo time.Time) (statistics.DependencyVulnAggregationStateAndChange, error)) *StatisticsService_GetDependencyVulnAggregationStateAndChangeSince_Call { + _c.Call.Return(run) + return _c +} + +// GetDependencyVulnCountByScannerID provides a mock function for the type StatisticsService +func (_mock *StatisticsService) GetDependencyVulnCountByScannerID(assetVersionName string, assetID uuid.UUID) (map[string]int, error) { + ret := _mock.Called(assetVersionName, assetID) + + if len(ret) == 0 { + panic("no return value specified for GetDependencyVulnCountByScannerID") + } + + var r0 map[string]int + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID) (map[string]int, error)); ok { + return returnFunc(assetVersionName, assetID) + } + if returnFunc, ok := ret.Get(0).(func(string, uuid.UUID) map[string]int); ok { + r0 = returnFunc(assetVersionName, assetID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]int) + } + } + if returnFunc, ok := ret.Get(1).(func(string, uuid.UUID) error); ok { + r1 = returnFunc(assetVersionName, assetID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// StatisticsService_GetDependencyVulnCountByScannerID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDependencyVulnCountByScannerID' +type StatisticsService_GetDependencyVulnCountByScannerID_Call struct { + *mock.Call +} + +// GetDependencyVulnCountByScannerID is a helper method to define mock.On call +// - assetVersionName string +// - assetID uuid.UUID +func (_e *StatisticsService_Expecter) GetDependencyVulnCountByScannerID(assetVersionName interface{}, assetID interface{}) *StatisticsService_GetDependencyVulnCountByScannerID_Call { + return &StatisticsService_GetDependencyVulnCountByScannerID_Call{Call: _e.mock.On("GetDependencyVulnCountByScannerID", assetVersionName, assetID)} +} + +func (_c *StatisticsService_GetDependencyVulnCountByScannerID_Call) Run(run func(assetVersionName string, assetID uuid.UUID)) *StatisticsService_GetDependencyVulnCountByScannerID_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 uuid.UUID + if args[1] != nil { + arg1 = args[1].(uuid.UUID) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *StatisticsService_GetDependencyVulnCountByScannerID_Call) Return(stringToInt map[string]int, err error) *StatisticsService_GetDependencyVulnCountByScannerID_Call { + _c.Call.Return(stringToInt, err) + return _c +} + +func (_c *StatisticsService_GetDependencyVulnCountByScannerID_Call) RunAndReturn(run func(assetVersionName string, assetID uuid.UUID) (map[string]int, error)) *StatisticsService_GetDependencyVulnCountByScannerID_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectRiskHistory provides a mock function for the type StatisticsService +func (_mock *StatisticsService) GetProjectRiskHistory(projectID uuid.UUID, start time.Time, end time.Time) ([]models.ProjectRiskHistory, error) { + ret := _mock.Called(projectID, start, end) + + if len(ret) == 0 { + panic("no return value specified for GetProjectRiskHistory") + } + + var r0 []models.ProjectRiskHistory + var r1 error + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, time.Time, time.Time) ([]models.ProjectRiskHistory, error)); ok { + return returnFunc(projectID, start, end) + } + if returnFunc, ok := ret.Get(0).(func(uuid.UUID, time.Time, time.Time) []models.ProjectRiskHistory); ok { + r0 = returnFunc(projectID, start, end) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]models.ProjectRiskHistory) + } + } + if returnFunc, ok := ret.Get(1).(func(uuid.UUID, time.Time, time.Time) error); ok { + r1 = returnFunc(projectID, start, end) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// StatisticsService_GetProjectRiskHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectRiskHistory' +type StatisticsService_GetProjectRiskHistory_Call struct { + *mock.Call +} + +// GetProjectRiskHistory is a helper method to define mock.On call +// - projectID uuid.UUID +// - start time.Time +// - end time.Time +func (_e *StatisticsService_Expecter) GetProjectRiskHistory(projectID interface{}, start interface{}, end interface{}) *StatisticsService_GetProjectRiskHistory_Call { + return &StatisticsService_GetProjectRiskHistory_Call{Call: _e.mock.On("GetProjectRiskHistory", projectID, start, end)} +} + +func (_c *StatisticsService_GetProjectRiskHistory_Call) Run(run func(projectID uuid.UUID, start time.Time, end time.Time)) *StatisticsService_GetProjectRiskHistory_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uuid.UUID + if args[0] != nil { + arg0 = args[0].(uuid.UUID) + } + var arg1 time.Time + if args[1] != nil { + arg1 = args[1].(time.Time) + } + var arg2 time.Time + if args[2] != nil { + arg2 = args[2].(time.Time) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *StatisticsService_GetProjectRiskHistory_Call) Return(projectRiskHistorys []models.ProjectRiskHistory, err error) *StatisticsService_GetProjectRiskHistory_Call { + _c.Call.Return(projectRiskHistorys, err) + return _c +} + +func (_c *StatisticsService_GetProjectRiskHistory_Call) RunAndReturn(run func(projectID uuid.UUID, start time.Time, end time.Time) ([]models.ProjectRiskHistory, error)) *StatisticsService_GetProjectRiskHistory_Call { + _c.Call.Return(run) + return _c +} + // UpdateAssetRiskAggregation provides a mock function for the type StatisticsService -func (_mock *StatisticsService) UpdateAssetRiskAggregation(assetVersion *models.AssetVersion, assetID uuid.UUID, begin time.Time, end time.Time, propagateToProject bool) error { - ret := _mock.Called(assetVersion, assetID, begin, end, propagateToProject) +func (_mock *StatisticsService) UpdateAssetRiskAggregation(assetVersion *models.AssetVersion, assetID uuid.UUID, start time.Time, end time.Time, updateProject bool) error { + ret := _mock.Called(assetVersion, assetID, start, end, updateProject) if len(ret) == 0 { panic("no return value specified for UpdateAssetRiskAggregation") @@ -121,7 +696,7 @@ func (_mock *StatisticsService) UpdateAssetRiskAggregation(assetVersion *models. var r0 error if returnFunc, ok := ret.Get(0).(func(*models.AssetVersion, uuid.UUID, time.Time, time.Time, bool) error); ok { - r0 = returnFunc(assetVersion, assetID, begin, end, propagateToProject) + r0 = returnFunc(assetVersion, assetID, start, end, updateProject) } else { r0 = ret.Error(0) } @@ -136,14 +711,14 @@ type StatisticsService_UpdateAssetRiskAggregation_Call struct { // UpdateAssetRiskAggregation is a helper method to define mock.On call // - assetVersion *models.AssetVersion // - assetID uuid.UUID -// - begin time.Time +// - start time.Time // - end time.Time -// - propagateToProject bool -func (_e *StatisticsService_Expecter) UpdateAssetRiskAggregation(assetVersion interface{}, assetID interface{}, begin interface{}, end interface{}, propagateToProject interface{}) *StatisticsService_UpdateAssetRiskAggregation_Call { - return &StatisticsService_UpdateAssetRiskAggregation_Call{Call: _e.mock.On("UpdateAssetRiskAggregation", assetVersion, assetID, begin, end, propagateToProject)} +// - updateProject bool +func (_e *StatisticsService_Expecter) UpdateAssetRiskAggregation(assetVersion interface{}, assetID interface{}, start interface{}, end interface{}, updateProject interface{}) *StatisticsService_UpdateAssetRiskAggregation_Call { + return &StatisticsService_UpdateAssetRiskAggregation_Call{Call: _e.mock.On("UpdateAssetRiskAggregation", assetVersion, assetID, start, end, updateProject)} } -func (_c *StatisticsService_UpdateAssetRiskAggregation_Call) Run(run func(assetVersion *models.AssetVersion, assetID uuid.UUID, begin time.Time, end time.Time, propagateToProject bool)) *StatisticsService_UpdateAssetRiskAggregation_Call { +func (_c *StatisticsService_UpdateAssetRiskAggregation_Call) Run(run func(assetVersion *models.AssetVersion, assetID uuid.UUID, start time.Time, end time.Time, updateProject bool)) *StatisticsService_UpdateAssetRiskAggregation_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 *models.AssetVersion if args[0] != nil { @@ -181,7 +756,7 @@ func (_c *StatisticsService_UpdateAssetRiskAggregation_Call) Return(err error) * return _c } -func (_c *StatisticsService_UpdateAssetRiskAggregation_Call) RunAndReturn(run func(assetVersion *models.AssetVersion, assetID uuid.UUID, begin time.Time, end time.Time, propagateToProject bool) error) *StatisticsService_UpdateAssetRiskAggregation_Call { +func (_c *StatisticsService_UpdateAssetRiskAggregation_Call) RunAndReturn(run func(assetVersion *models.AssetVersion, assetID uuid.UUID, start time.Time, end time.Time, updateProject bool) error) *StatisticsService_UpdateAssetRiskAggregation_Call { _c.Call.Return(run) return _c }