Fossology URL and Token validation in SW360

src/LCT.APICommunications/Interfaces/ISW360APICommunication.cs

@@ -40,5 +40,6 @@ public interface ISw360ApiCommunication
         string AttachComponentSourceToSW360(AttachReport attachReport);
         void DownloadAttachmentUsingWebClient(string attachmentDownloadLink, string fileName);
         Task<HttpResponseMessage> GetComponentDetailsByUrl(string componentLink);
+        Task<HttpResponseMessage> GetAllReleasesWithAllData(int page, int pageEntries);
     }
 }

src/LCT.APICommunications/SW360Apicommunication.cs

@@ -313,6 +313,12 @@ public async Task<HttpResponseMessage> GetComponentUsingName(string componentNam
             string url = $"{sw360ComponentApi}{ApiConstant.ComponentNameUrl}{componentName}";
             return await httpClient.GetAsync(url);
         }
+        public async Task<HttpResponseMessage> GetAllReleasesWithAllData(int page, int pageEntries)
+        {
+            HttpClient httpClient = GetHttpClient();            
+            string url = $"{sw360ReleaseApi}?page={page}&allDetails=true&page_entries={pageEntries}";
+            return await httpClient.GetAsync(url);           
+        }
         #endregion
 
         #region PRIVATE METHODS

src/LCT.Common/CommonAppSettings.cs

@@ -172,7 +172,8 @@ public string URL
             }
             set
             {
-                if (AppDomain.CurrentDomain.FriendlyName.Contains("SW360PackageCreator"))
+                if (!AppDomain.CurrentDomain.FriendlyName.Contains("PackageIdentifier") &&
+                    !AppDomain.CurrentDomain.FriendlyName.Contains("ArtifactoryUploader"))
                 {
                     if (string.IsNullOrEmpty(value))
                     {

src/LCT.Common/Constants/Dataconstant.cs

@@ -68,6 +68,8 @@ public static class Dataconstant
         public const string Cdx_Siemensfilename = "internal:siemens:clearing:siemens:filename";
         public const string Cdx_SiemensDirect = "internal:siemens:clearing:siemens:direct";
         public const string Cdx_ExcludeComponent = "internal:siemens:clearing:sw360:exclude";
+        public const string ProductionFossologyURL = "automation.fossology";
+        public const string StageFossologyURL = "stage.fossology";
 
         public static Dictionary<string, string> PurlCheck()
         {

src/LCT.Common/PipelineArtifactUploader.cs

@@ -26,10 +26,10 @@ public static void UploadArtifacts()
         /// </summary>
         public static void UploadLogs()
         {
-            EnvironmentType envType = RuntimeEnvironment.GetEnvironment();
-            LogManager.Shutdown();
+            EnvironmentType envType = RuntimeEnvironment.GetEnvironment();           
             if (envType == EnvironmentType.AzurePipeline && !string.IsNullOrEmpty(Log4Net.CatoolLogPath) && File.Exists(Log4Net.CatoolLogPath))
-            {                
+            {
+                LogManager.Shutdown();
                 Console.WriteLine($"##vso[artifact.upload containerfolder={LogContainerFolderName};artifactname={LogArtifactFolderName}]{Log4Net.CatoolLogPath}");
             }
             else if (envType == EnvironmentType.Unknown)
@@ -44,7 +44,7 @@ public static void UploadLogs()
         /// </summary>
         public static void UploadBom()
         {
-            EnvironmentType envType = RuntimeEnvironment.GetEnvironment();
+            EnvironmentType envType = RuntimeEnvironment.GetEnvironment();            
             if (envType == EnvironmentType.AzurePipeline && !string.IsNullOrEmpty(FileOperations.CatoolBomFilePath) && File.Exists(FileOperations.CatoolBomFilePath))
             {
                 Console.WriteLine($"##vso[artifact.upload containerfolder={BomContainerFolderName};artifactname={BomArtifactFolderName}]{FileOperations.CatoolBomFilePath}");

src/LCT.Facade/Interfaces/ISW360ApicommunicationFacade.cs

@@ -43,5 +43,6 @@ public interface ISW360ApicommunicationFacade
         Task<HttpResponseMessage> UpdateLinkedRelease(string projectId, string releaseId, UpdateLinkedRelease updateLinkedRelease);
         Task<HttpResponseMessage> GetReleaseByExternalId(string purlId,string externalIdKey = "");
         Task<HttpResponseMessage> GetComponentByExternalId(string purlId, string externalIdKey = "");
+        Task<HttpResponseMessage> GetAllReleasesWithAllData(int page, int pageEntries);
     }
 }

src/LCT.Facade/SW360ApicommunicationFacade.cs

@@ -195,5 +195,9 @@ public Task<HttpResponseMessage> GetComponentByExternalId(string purlId, string
         {
             return m_sw360ApiCommunication.GetComponentByExternalId(purlId, externalIdKey);
         }
+        public Task<HttpResponseMessage> GetAllReleasesWithAllData(int page, int pageEntries)
+        {
+            return m_sw360ApiCommunication.GetAllReleasesWithAllData(page, pageEntries);
+        }
     }
 }

src/LCT.SW360PackageCreator.UTest/CreatorValidatorTest.cs

@@ -13,24 +13,46 @@
 using LCT.Common;
 using System.Threading.Tasks;
 using LCT.APICommunications.Model;
+using LCT.Facade.Interfaces;
+using LCT.APICommunications.Model.Foss;
+using Newtonsoft.Json;
+using System.Net.Http;
+using LCT.Common.Interface;
+using System.Net;
+using System.Threading;
+using Moq.Protected;
+using System.Security.Policy;
+using System.Reflection;
 
 namespace LCT.SW360PackageCreator.UTest
 {
     [TestFixture]
     public class CreatorValidatorTest
     {
         public Mock<ISw360ProjectService> mockISw360ProjectService;
+        private Mock<ISW360ApicommunicationFacade> mockISW360ApicommunicationFacade;
+        private Mock<ISW360Service> mockISW360Service;
+        private Mock<ISw360CreatorService> mockISw360CreatorService;
+        private Mock<IEnvironmentHelper> mockEnvironmentHelper;
+        private Mock<HttpMessageHandler> mockHttpMessageHandler;
+        private HttpClient httpClient;
         public CreatorValidatorTest()
         {
             mockISw360ProjectService = new Mock<ISw360ProjectService>(MockBehavior.Strict);
+            mockISW360ApicommunicationFacade = new Mock<ISW360ApicommunicationFacade>();
+            mockISW360Service = new Mock<ISW360Service>();
+            mockISw360CreatorService = new Mock<ISw360CreatorService>();
+            mockEnvironmentHelper = new Mock<IEnvironmentHelper>();
+            mockHttpMessageHandler = new Mock<HttpMessageHandler>();
+            httpClient = new HttpClient(mockHttpMessageHandler.Object);
 
         }
         [TestCase]
         public async Task ValidateAppSettings_TestPositive()
         {
             //Arrange
             string projectName = "Test";
-            ProjectReleases projectReleases=new ProjectReleases();
+            ProjectReleases projectReleases = new ProjectReleases();
             var CommonAppSettings = new CommonAppSettings()
             {
                 SW360 = new SW360()
@@ -42,7 +64,7 @@ public async Task ValidateAppSettings_TestPositive()
                 .ReturnsAsync(projectName);
 
             //Act
-            await CreatorValidator.ValidateAppSettings(CommonAppSettings, mockISw360ProjectService.Object,projectReleases);
+            await CreatorValidator.ValidateAppSettings(CommonAppSettings, mockISw360ProjectService.Object, projectReleases);
 
             //Assert
             mockISw360ProjectService.Verify(x => x.GetProjectNameByProjectIDFromSW360(It.IsAny<string>(), It.IsAny<string>(), projectReleases), Times.AtLeastOnce);
@@ -59,10 +81,10 @@ public async Task ValidateAppSettings_OnClosedProject_EndsTheApplication()
             {
                 SW360 = new SW360()
                 {
-                   ProjectName= "Test"
+                    ProjectName = "Test"
                 }
             };
-            
+
             mockISw360ProjectService.Setup(x => x.GetProjectNameByProjectIDFromSW360(It.IsAny<String>(), It.IsAny<string>(), projectReleases))
                 .ReturnsAsync(projectName);
 
@@ -82,9 +104,9 @@ public void ValidateAppSettings_TestNegative()
             ProjectReleases projectReleases = new ProjectReleases();
             var CommonAppSettings = new CommonAppSettings()
             {
-                SW360=new SW360()
+                SW360 = new SW360()
             };
-            mockISw360ProjectService.Setup(x => x.GetProjectNameByProjectIDFromSW360(It.IsAny<string>(), It.IsAny<string>(),projectReleases))
+            mockISw360ProjectService.Setup(x => x.GetProjectNameByProjectIDFromSW360(It.IsAny<string>(), It.IsAny<string>(), projectReleases))
                 .ReturnsAsync(projectName);
 
             //Act
@@ -93,6 +115,170 @@ public void ValidateAppSettings_TestNegative()
             Assert.ThrowsAsync<InvalidDataException>(() => CreatorValidator.ValidateAppSettings(CommonAppSettings, mockISw360ProjectService.Object, projectReleases));
 
         }
+        [Test]
+        public async Task TriggerFossologyValidation_TestPositive()
+        {
+            // Arrange
+            var appSettings = new CommonAppSettings()
+            {
+                SW360 = new SW360()
+                {
+                    URL = "https://sw360.example.com"
+                }
+            };
+
+            var responseBody = "{\"_embedded\":{\"sw360:releases\":[{\"id\":\"a3c5c9d1dd469d668433fb147c01bad2\",\"name\":\"HC-Test Pugixml\",\"version\":\"V1.2\",\"clearingState\":\"APPROVED\",\"_embedded\":{\"sw360:attachments\":[[{\"filename\":\"Protocol_Pugixml - 1.2.doc\"}]]},\"_links\":{\"self\":{\"href\":\"https://sw360.siemens.com/resource/api/releases/a3c5c9d1dd469d668433fb147c01bad2\"}}}]},\"page\":{\"totalPages\":1}}";
+            var releasesInfo = new ReleasesInfo
+            {
+                Name = "TestRelease",
+                Version = "1.0",
+                ClearingState = "APPROVED"
+            };
+            var fossTriggerStatus = new FossTriggerStatus
+            {
+                Links = new Links
+                {
+                    Self = new Self
+                    {
+                        Href = "https://fossology.example.com"
+                    }
+                }
+            };
+
+            var triggerStatusResponse = JsonConvert.SerializeObject(fossTriggerStatus);
+
+            mockISW360ApicommunicationFacade.Setup(x => x.GetAllReleasesWithAllData(It.IsAny<int>(), It.IsAny<int>())).ReturnsAsync(new HttpResponseMessage
+            {
+                Content = new StringContent(responseBody)
+            });
+
+            mockISW360ApicommunicationFacade.Setup(x => x.TriggerFossologyProcess(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(triggerStatusResponse);
+
+            mockISw360CreatorService.Setup(x => x.TriggerFossologyProcessForValidation(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(fossTriggerStatus);
+
+            // Act
+            await CreatorValidator.TriggerFossologyValidation(appSettings, mockISW360ApicommunicationFacade.Object);
+
+            // Assert
+            mockISW360ApicommunicationFacade.Verify(x => x.GetAllReleasesWithAllData(It.IsAny<int>(), It.IsAny<int>()), Times.Once);
+            mockISW360ApicommunicationFacade.Verify(x => x.TriggerFossologyProcess(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+        }
+        [Test]
+        public async Task FossologyUrlValidation_ValidUrl_ReturnsTrue()
+        {
+            // Arrange
+            var appSettings = new CommonAppSettings()
+            {
+                SW360 = new SW360()
+                {
+                    Fossology = new Fossology()
+                    {
+                        URL = "https://stage.fossology.url"
+                    }
+                }
+            };
+            var responseMessage = new HttpResponseMessage(HttpStatusCode.OK);
+            mockHttpMessageHandler
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>(
+                    "SendAsync",
+                    ItExpr.IsAny<HttpRequestMessage>(),
+                    ItExpr.IsAny<CancellationToken>()
+                )
+                .ReturnsAsync(responseMessage);
+            // Act
+            var result = await CreatorValidator.FossologyUrlValidation(appSettings, httpClient, mockEnvironmentHelper.Object);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public async Task FossologyUrlValidation_InvalidUrl_ReturnsFalse()
+        {
+            // Arrange
+            var appSettings = new CommonAppSettings()
+            {
+                SW360 = new SW360()
+                {
+                    Fossology = new Fossology()
+                    {
+                        URL = "https://invalid.fossology.url"
+                    }
+                }
+            };
+
+            var responseMessage = new HttpResponseMessage(HttpStatusCode.NotFound);
+            mockHttpMessageHandler
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>(
+                    "SendAsync",
+                    ItExpr.IsAny<HttpRequestMessage>(),
+                    ItExpr.IsAny<CancellationToken>()
+                )
+                .ReturnsAsync(responseMessage);
+
+            // Act
+            var result = await CreatorValidator.FossologyUrlValidation(appSettings, httpClient, mockEnvironmentHelper.Object);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+
+        [Test]
+        public async Task FossologyUrlValidation_InvalidUri_ThrowsException()
+        {
+            // Arrange
+            var appSettings = new CommonAppSettings()
+            {
+                SW360 = new SW360()
+                {
+                    Fossology = new Fossology()
+                    {
+                        URL = "invalid_uri"
+                    }
+                }
+            };
+
+            var result = await CreatorValidator.FossologyUrlValidation(appSettings, httpClient, mockEnvironmentHelper.Object);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public async Task FossologyUrlValidation_HttpRequestException_ReturnsFalse()
+        {
+            // Arrange
+            var appSettings = new CommonAppSettings()
+            {
+                SW360 = new SW360()
+                {
+                    Fossology = new Fossology()
+                    {
+                        URL = "https://valid.fossology.url"
+                    }
+                }
+            };
+
+            mockHttpMessageHandler
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>(
+                    "SendAsync",
+                    ItExpr.IsAny<HttpRequestMessage>(),
+                    ItExpr.IsAny<CancellationToken>()
+                )
+                .ThrowsAsync(new HttpRequestException());
+
+            // Act
+            var result = await CreatorValidator.FossologyUrlValidation(appSettings, httpClient, mockEnvironmentHelper.Object);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+
 
     }
 }