Code Clean up for Package Identifier and creator

Author: Sridhar, NIVETHA (ext) (FT D AA IN SGI EA EBT BE)

src/LCT.Common.UTests/CommonAppSettingsTests.cs

@@ -18,7 +18,7 @@ private class TestDirectory(IEnvironmentHelper envHelper) : LCT.Common.Directory
         {
 
             // Override to always throw DirectoryNotFoundException
-            protected new void ValidateFolderPath(string value)
+            protected static void ValidateFolderPath(string value)
             {
                 throw new DirectoryNotFoundException("Test exception");
             }
@@ -32,10 +32,11 @@ public void InputFolder_WhenDirectoryNotFoundException_LogsErrorAndCallsExit()
             bool exitCalled = false;
             envHelperMock.Setup(e => e.CallEnvironmentExit(It.IsAny<int>())).Callback(() => exitCalled = true);
 
-            var testDirectory = new TestDirectory(envHelperMock.Object);
-
-            // Act
-            testDirectory.InputFolder = "nonexistent_path";
+            var testDirectory = new TestDirectory(envHelperMock.Object)
+            {
+                // Act
+                InputFolder = "nonexistent_path"
+            };
 
             // Assert
             Assert.IsTrue(exitCalled, "Environment exit should be called on DirectoryNotFoundException.");

src/LCT.Facade/SW360ApicommunicationFacade.cs

@@ -240,7 +240,6 @@ public void GetArtifactoryRepoName_ReturnsNotFoundInRepo_WhenNoMatch()
             var aqlResultList = new List<AqlResult>();
             var component = new Component { Name = "Test", Version = "1.0" };
             var bomHelper = new Mock<IBomHelper>();
-            string jfrogPackageName, jfrogRepoPath;
             var method = typeof(CargoProcessor).GetMethod("GetArtifactoryRepoName", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
 
             var repoName = (string)method.Invoke(null, new object[] { aqlResultList, component, bomHelper.Object, null, null });

src/LCT.PackageIdentifier.UTest/CargoProcessorTests.cs

@@ -67,7 +67,6 @@ public void DisplayIncludeFiles_EmptyInclude_ReturnsEmptyString(string projectTy
             Assert.AreEqual(string.Empty, result);
         }
         private CommonAppSettings appSettings;
-        private CatoolInfo caToolInformation;
         private MemoryAppender memoryAppender;
 
         [SetUp]

src/LCT.PackageIdentifier.UTest/DisplayInformationTests.cs

@@ -26,14 +26,29 @@ namespace LCT.PackageIdentifier
     /// </summary>
     public class AlpineProcessor(ICycloneDXBomParser cycloneDXBomParser, ISpdxBomParser spdxBomParser) : IParser
     {
+        #region Fields
         private const string ProjectTypeAlpine = "ALPINE";
         static readonly ILog Logger = LoggerFactory.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
         private readonly ICycloneDXBomParser _cycloneDXBomParser = cycloneDXBomParser;
         private readonly ISpdxBomParser _spdxBomParser = spdxBomParser;
         private static Bom ListUnsupportedComponentsForBom = new Bom { Components = new List<Component>(), Dependencies = new List<Dependency>() };
+        #endregion
+
         private readonly IEnvironmentHelper _environmentHelper = new EnvironmentHelper();
-        #region public method
+        #region Properties
+        #endregion
 
+        #region Constructors
+        // Primary constructor parameters are declared on the class.
+        #endregion
+
+        #region Methods
+        /// <summary>
+        /// Parses Alpine package files from the configured input folder and builds a BOM.
+        /// </summary>
+        /// <param name="appSettings">Application settings with input and processing options.</param>
+        /// <param name="unSupportedBomList">Reference BOM that will be populated with unsupported components.</param>
+        /// <returns>BOM built from discovered Alpine packages.</returns>
         public Bom ParsePackageFile(CommonAppSettings appSettings, ref Bom unSupportedBomList)
         {
             List<string> configFiles;
@@ -78,12 +93,26 @@ public Bom ParsePackageFile(CommonAppSettings appSettings, ref Bom unSupportedBo
             return bom;
         }
 
+        /// <summary>
+        /// Removes components excluded in settings from the provided BOM.
+        /// </summary>
+        /// <param name="appSettings">Application settings.</param>
+        /// <param name="cycloneDXBOM">BOM to filter.</param>
+        /// <returns>Filtered BOM.</returns>
         public static Bom RemoveExcludedComponents(CommonAppSettings appSettings, Bom cycloneDXBOM)
         {
             return CommonHelper.RemoveExcludedComponentsFromBom(appSettings, cycloneDXBOM,
                 noOfExcludedComponents => BomCreator.bomKpiData.ComponentsExcludedSW360 += noOfExcludedComponents);
         }
 
+        /// <summary>
+        /// Asynchronously retrieves repository details for the provided components and returns a modified list.
+        /// </summary>
+        /// <param name="componentsForBOM">List of components to enrich.</param>
+        /// <param name="appSettings">Application settings.</param>
+        /// <param name="jFrogService">JFrog service to query (may be null).</param>
+        /// <param name="bomhelper">BOM helper utilities.</param>
+        /// <returns>Asynchronously returns the modified list of components.</returns>
         public async Task<List<Component>> GetJfrogRepoDetailsOfAComponent(List<Component> componentsForBOM, CommonAppSettings appSettings,
                                                           IJFrogService jFrogService,
                                                           IBomHelper bomhelper)
@@ -98,24 +127,42 @@ public async Task<List<Component>> GetJfrogRepoDetailsOfAComponent(List<Componen
             return modifiedBOM;
         }
 
+        /// <summary>
+        /// Asynchronously identifies internal components using JFrog and BOM helper; returns input unchanged in current implementation.
+        /// </summary>
+        /// <param name="componentData">Component identification data to analyze.</param>
+        /// <param name="appSettings">Application settings.</param>
+        /// <param name="jFrogService">JFrog service to query.</param>
+        /// <param name="bomhelper">BOM helper utilities.</param>
+        /// <returns>Asynchronously returns the (possibly modified) component identification data.</returns>
         public async Task<ComponentIdentification> IdentificationOfInternalComponents(ComponentIdentification componentData,
             CommonAppSettings appSettings, IJFrogService jFrogService, IBomHelper bomhelper)
         {
             await Task.Yield();
             return componentData;
         }
 
-        #endregion
-
-        #region private methods
-
+        /// <summary>
+        /// Parses a CycloneDX SBOM file and returns a list of AlpinePackage entries.
+        /// </summary>
+        /// <param name="filePath">Path to the CycloneDX/ SPDX file.</param>
+        /// <param name="dependenciesForBOM">List to collect BOM dependencies.</param>
+        /// <param name="appSettings">Application settings.</param>
+        /// <returns>List of parsed AlpinePackage instances.</returns>
         public List<AlpinePackage> ParseCycloneDX(string filePath, List<Dependency> dependenciesForBOM, CommonAppSettings appSettings)
         {
             List<AlpinePackage> alpinePackages = new List<AlpinePackage>();
             ExtractDetailsForJson(filePath, ref alpinePackages, dependenciesForBOM, appSettings);
             return alpinePackages;
         }
 
+        /// <summary>
+        /// Extracts package details from a BOM file and populates provided collections with packages and dependencies.
+        /// </summary>
+        /// <param name="filePath">Path to the BOM file.</param>
+        /// <param name="alpinePackages">Reference list to append discovered Alpine packages.</param>
+        /// <param name="dependenciesForBOM">List to collect dependencies discovered in the BOM.</param>
+        /// <param name="appSettings">Application settings.</param>
         private void ExtractDetailsForJson(string filePath, ref List<AlpinePackage> alpinePackages, List<Dependency> dependenciesForBOM, CommonAppSettings appSettings)
         {
             Bom listUnsupportedComponents = new Bom { Components = new List<Component>(), Dependencies = new List<Dependency>() };
@@ -151,6 +198,11 @@ private void ExtractDetailsForJson(string filePath, ref List<AlpinePackage> alpi
             ListUnsupportedComponentsForBom.Components.AddRange(listUnsupportedComponents.Components);
             ListUnsupportedComponentsForBom.Dependencies.AddRange(listUnsupportedComponents.Dependencies);
         }
+
+        /// <summary>
+        /// Removes duplicate components from the provided list and updates KPI data.
+        /// </summary>
+        /// <param name="listofComponents">Reference to the component list to deduplicate.</param>
         private static string GetReleaseExternalId(string name, string version)
         {
             return BomHelper.GetReleaseExternalId(name, version, Dataconstant.PurlCheck()[ProjectTypeAlpine]);
@@ -174,6 +226,11 @@ private static string GetDistro(AlpinePackage alpinePackage)
             return alpinePackage.PurlID[distroIndex..];
         }
 
+        /// <summary>
+        /// Forms a list of CycloneDX Component objects from parsed Alpine packages, adding PURLs and properties.
+        /// </summary>
+        /// <param name="listOfComponents">List of parsed Alpine packages.</param>
+        /// <returns>List of components ready for BOM insertion.</returns>
         private static List<Component> FormComponentReleaseExternalID(List<AlpinePackage> listOfComponents)
         {
             List<Component> listComponentForBOM = new List<Component>();
@@ -194,6 +251,12 @@ private static List<Component> FormComponentReleaseExternalID(List<AlpinePackage
             }
             return listComponentForBOM;
         }
+
+        /// <summary>
+        /// Adds properties to a CycloneDX component based on SPDX information or discovery metadata.
+        /// </summary>
+        /// <param name="prop">Parsed Alpine package information.</param>
+        /// <param name="component">Component to enrich.</param>
         private static void AddComponentProperties(AlpinePackage prop, Component component)
         {
             if (prop.SpdxComponentDetails.SpdxComponent)
@@ -209,6 +272,13 @@ private static void AddComponentProperties(AlpinePackage prop, Component compone
                 component.Properties.Add(identifierType);
             }
         }
+
+        /// <summary>
+        /// Sets SPDX related details on an AlpinePackage when the source file is an SPDX file.
+        /// </summary>
+        /// <param name="filePath">Source file path.</param>
+        /// <param name="package">Alpine package to update.</param>
+        /// <param name="componentInfo">Component information parsed from the BOM.</param>
         private static void SetSpdxComponentDetails(string filePath, AlpinePackage package, Component componentInfo)
         {
             if (filePath.EndsWith(FileConstant.SPDXFileExtension))
@@ -220,5 +290,8 @@ private static void SetSpdxComponentDetails(string filePath, AlpinePackage packa
         }
 
         #endregion
+
+        #region Events
+        #endregion
     }
 }

src/LCT.PackageIdentifier/AlpineProcesser.cs

@@ -37,31 +37,48 @@ namespace LCT.PackageIdentifier
     /// </summary>
     public class BomCreator : IBomCreator
     {
+        #region Fields
         private const string JFrogConnValidationContext = "JFrog Connection Validation";
         private const string CheckJFrogConnectionMethod = "Methodname:CheckJFrogConnection()";
         static readonly ILog Logger = LoggerFactory.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
         public readonly static BomKpiData bomKpiData = new();
         ComponentIdentification componentData;
         private readonly ICycloneDXBomParser CycloneDXBomParser;
         private readonly ISpdxBomParser SpdxBomParser;
-        public IJFrogService JFrogService { get; set; }
-        public IBomHelper BomHelper { get; set; }
-
         private readonly IFrameworkPackages _frameworkPackages;
         private readonly ICompositionBuilder _compositionBuilder;
         private readonly IRuntimeIdentifier _runtimeIdentifier;
 
         public static Jfrog jfrog { get; set; } = new Jfrog();
         public static SW360 sw360 { get; set; } = new SW360();
+        #endregion
+
+        #region Properties
+        public IJFrogService JFrogService { get; set; }
+        public IBomHelper BomHelper { get; set; }
+        #endregion
+
+        #region Constructors
         public BomCreator(ICycloneDXBomParser cycloneDXBomParser, IFrameworkPackages frameworkPackages, ICompositionBuilder compositionBuilder, ISpdxBomParser spdxBomParser, IRuntimeIdentifier runtimeIdentifier)
         {
             CycloneDXBomParser = cycloneDXBomParser;
-            _frameworkPackages = frameworkPackages;
+            _frameworkPackages = frameworkPackages; 
             _compositionBuilder = compositionBuilder;
             SpdxBomParser = spdxBomParser;
             _runtimeIdentifier = runtimeIdentifier;
         }
+        #endregion
+       
 
+        /// <summary>
+        /// Asynchronously generates a CycloneDX BOM from configured inputs and writes outputs (BOM, KPI files).
+        /// </summary>
+        /// <param name="appSettings">Application settings used for generation.</param>
+        /// <param name="bomHelper">BOM helper utilities.</param>
+        /// <param name="fileOperations">File operations helper used to write outputs.</param>
+        /// <param name="projectReleases">Project releases data used to enrich metadata.</param>
+        /// <param name="caToolInformation">CA tool information for telemetry/metadata.</param>
+        /// <returns>Asynchronously completes when generation finishes.</returns>
         public async Task GenerateBom(CommonAppSettings appSettings,
                                       IBomHelper bomHelper,
                                       IFileOperations fileOperations,
@@ -128,11 +145,25 @@ public async Task GenerateBom(CommonAppSettings appSettings,
             Logger.Debug($"GenerateBom():SBOM generation process has completed.\n");
         }
 
+        /// <summary>
+        /// Writes contents to BOM by delegating to CycloneDX writer.
+        /// </summary>
+        /// <param name="appSettings">Application settings.</param>
+        /// <param name="bomKpiData">KPI data structure to update.</param>
+        /// <param name="listOfComponentsToBom">BOM to write.</param>
+        /// <param name="defaultProjectName">Default project name used in file naming.</param>
         private static void WritecontentsToBOM(CommonAppSettings appSettings, BomKpiData bomKpiData, Bom listOfComponentsToBom, string defaultProjectName)
         {
             WriteContentToCycloneDxBOM(appSettings, listOfComponentsToBom, ref bomKpiData, defaultProjectName);
         }
 
+        /// <summary>
+        /// Writes a CycloneDX BOM file to the output folder, optionally merging with existing BOMs when configured.
+        /// </summary>
+        /// <param name="appSettings">Application settings.</param>
+        /// <param name="listOfComponentsToBom">BOM object containing components and metadata.</param>
+        /// <param name="bomKpiData">KPI data reference that can be modified.</param>
+        /// <param name="defaultProjectName">Default project name used for file naming.</param>
         private static void WriteContentToCycloneDxBOM(CommonAppSettings appSettings, Bom listOfComponentsToBom, ref BomKpiData bomKpiData, string defaultProjectName)
         {
             FileOperations fileOperations = new FileOperations();
@@ -161,6 +192,11 @@ private static void WriteContentToCycloneDxBOM(CommonAppSettings appSettings, Bo
 
         }
 
+        /// <summary>
+        /// Asynchronously selects and invokes the appropriate package parser based on project type.
+        /// </summary>
+        /// <param name="appSettings">Application settings which include ProjectType.</param>
+        /// <returns>Asynchronously returns the generated BOM from the selected parser.</returns>
         private async Task<Bom> CallPackageParser(CommonAppSettings appSettings)
         {
             IParser parser;
@@ -202,6 +238,12 @@ private async Task<Bom> CallPackageParser(CommonAppSettings appSettings)
             return new Bom();
         }
 
+        /// <summary>
+        /// Asynchronously runs component identification and enrichment using the provided parser.
+        /// </summary>
+        /// <param name="appSettings">Application settings used by the parser.</param>
+        /// <param name="parser">Parser that will parse package files and identify components.</param>
+        /// <returns>Asynchronously returns the composed BOM.</returns>
         private async Task<Bom> ComponentIdentification(CommonAppSettings appSettings, IParser parser)
         {
             Logger.Debug("ComponentIdentification():Component identification process for BOM file has started.");
@@ -256,6 +298,12 @@ private async Task<Bom> ComponentIdentification(CommonAppSettings appSettings, I
             Logger.Debug("ComponentIdentification():Component identification process for BOM file has completed.");
             return bom;
         }
+
+        /// <summary>
+        /// Asynchronously checks connectivity to JFrog using the configured JFrog service.
+        /// </summary>
+        /// <param name="appSettings">Application settings containing JFrog configuration.</param>
+        /// <returns>Asynchronously returns true when connection is successful or JFrog is not configured; otherwise false.</returns>
         public async Task<bool> CheckJFrogConnection(CommonAppSettings appSettings)
         {
             Logger.Debug("CheckJFrogConnection():Validating JFrog Connection has started");
@@ -293,5 +341,9 @@ public async Task<bool> CheckJFrogConnection(CommonAppSettings appSettings)
             return true;
 
         }
+        
+
+        #region Events
+        #endregion
     }
 }