Code coverage

Author: ragavareddychalapala

src/LCT.APICommunications.UTest/AttachmentHelperUTest.cs

@@ -0,0 +1,86 @@
+using LCT.APICommunications.Model;
+using log4net;
+using Moq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Security;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LCT.APICommunications.UTest
+{
+    [TestFixture]
+    public class AttachmentHelperUTest
+    {        
+        private readonly string _sw360AuthToken = "mockToken";
+        private readonly string _sw360AuthTokenType = "Bearer";
+        private readonly string _sw360ReleaseApi = "https://api.mock.com/release";
+        private readonly string _attachmentFilePath = "mockFilePath";
+        private AttachmentHelper _attachmentHelper;
+
+        [SetUp]
+        public void SetUp()
+        {            
+
+            // Initialize the AttachmentHelper with mock logger.
+            _attachmentHelper = new AttachmentHelper(_sw360AuthTokenType, _sw360AuthToken, _sw360ReleaseApi);
+        }
+
+        [Test]
+        public void AttachComponentSourceToSW360_ValidInput_ReturnsCorrectUrl()
+        {
+            // Arrange
+            var attachReport = new AttachReport
+            {
+                ReleaseId = "123",
+                AttachmentFile = _attachmentFilePath,
+                AttachmentType = "Source",
+                AttachmentReleaseComment = "Test comment"
+            };
+
+            // Mock WebRequest behavior
+            var webRequestMock = new Mock<HttpWebRequest>();
+            var webResponseMock = new Mock<WebResponse>();
+
+            // Simulate valid response
+            webRequestMock.Setup(x => x.GetRequestStream()).Returns(new MemoryStream());
+            webRequestMock.Setup(x => x.GetResponse()).Returns(webResponseMock.Object);
+
+            // Act
+            var result = _attachmentHelper.AttachComponentSourceToSW360(attachReport);
+
+            // Assert
+            Assert.AreEqual("https://api.mock.com/release/123/attachments", result);
+        }        
+
+        [Test]
+        public void WriteAttachmentsJSONFile_CreatesValidJSONFile()
+        {
+            // Arrange
+            var attachReport = new AttachReport
+            {
+                AttachmentType = "Source",
+                AttachmentReleaseComment = "Test comment"
+            };
+            string folderPath = Path.Combine(Path.GetTempPath(), "ClearingTool/DownloadedFiles");
+            string fileName = "Attachment.json";
+
+            // Act
+            AttachmentHelper.WriteAttachmentsJSONFile(fileName, folderPath, attachReport);
+
+            // Assert
+            var jsonFilePath = Path.Combine(folderPath, "Attachment.json");
+            Assert.IsTrue(File.Exists(jsonFilePath));
+
+            // Validate JSON content
+            var fileContent = File.ReadAllText(jsonFilePath);
+            Assert.IsTrue(fileContent.Contains("Source"));
+            Assert.IsTrue(fileContent.Contains("Test comment"));
+
+            // Cleanup
+            File.Delete(jsonFilePath);
+        }
+    }
+}

src/LCT.APICommunications.UTest/DebianJfrogAPICommunicationUTest.cs

@@ -6,16 +6,39 @@
 
 
 using LCT.APICommunications.Model;
+using Moq;
+using Moq.Protected;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
 
 namespace LCT.APICommunications.UTest
 {
     [TestFixture]
     public class DebainJfrogAPICommunicationUTest
     {
+        private Mock<HttpMessageHandler> _mockHandler;
+        private HttpClient _httpClient;
+        private DebianJfrogAPICommunication _debianJfrogAPICommunication;
+        private ArtifactoryCredentials _credentials;
+        private string _repoDomainName;
+        private string _srcrepoName;
+        private int _timeout;
         [SetUp]
         public void Setup()
         {
-            // Method intentionally left empty.
+            // Setup the necessary parameters for creating an instance of DebianJfrogAPICommunication
+            _repoDomainName = "https://example.jfrog.io";
+            _srcrepoName = "my-repo";
+            _credentials = new ArtifactoryCredentials { Token = "sample-token" };
+            _timeout = 30;
+
+            // Mock the HttpMessageHandler to mock the HTTP calls
+            _mockHandler = new Mock<HttpMessageHandler>();
+            _httpClient = new HttpClient(_mockHandler.Object);
+
+            // Initialize the DebianJfrogAPICommunication object
+            _debianJfrogAPICommunication = new DebianJfrogAPICommunication(_repoDomainName, _srcrepoName, _credentials, _timeout);
         }
 
         [Test]
@@ -56,5 +79,74 @@ public void DebainJfrogApiCommunication_GetPackageInfo_ReturnsInvalidOperationEx
             //Assert
             Assert.ThrowsAsync<InvalidOperationException>(async () => await jfrogApicommunication.GetPackageInfo(new ComponentsToArtifactory()));
         }
+        [Test]
+        public async Task GetApiKey_ReturnsSuccessfulResponse()
+        {
+            // Arrange
+            var expectedResponse = new HttpResponseMessage(HttpStatusCode.OK);
+
+            // Mock the SendAsync method to return the expected response
+            _mockHandler
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>(
+                    "SendAsync",
+                    ItExpr.Is<HttpRequestMessage>(req =>
+                        req.Method == HttpMethod.Get && req.RequestUri.ToString() == $"{_repoDomainName}/api/security/apiKey"),
+                    ItExpr.IsAny<CancellationToken>())
+                .ReturnsAsync(expectedResponse)
+                .Verifiable();
+
+            // Act
+            var result = await _debianJfrogAPICommunication.GetApiKey();
+
+            // Assert
+            Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
+        }
+        [Test]
+        public async Task MoveFromRepo_ReturnsSuccessfulResponse()
+        {
+            // Arrange
+            var component = new ComponentsToArtifactory
+            {
+                MovePackageApiUrl = $"{_repoDomainName}/api/move/package"  // Example URL
+            };
+
+            var expectedResponse = new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent("Move successful")
+            };
+
+            // Mock the SendAsync method to return the expected response
+            _mockHandler
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>(
+                    "SendAsync",
+                    ItExpr.Is<HttpRequestMessage>(req =>
+                        req.Method == HttpMethod.Post && req.RequestUri.ToString() == component.MovePackageApiUrl),
+                    ItExpr.IsAny<CancellationToken>())
+                .ReturnsAsync(expectedResponse)
+                .Verifiable();
+
+            // Act
+            var result = await _debianJfrogAPICommunication.MoveFromRepo(component);
+
+            // Assert
+            Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
+        }
+    }
+    public static class HttpMessageHandlerExtensions
+    {
+        public static Mock<HttpMessageHandler> SetupRequest(this Mock<HttpMessageHandler> mockHandler, HttpMethod method, string requestUri)
+        {
+            var request = new HttpRequestMessage(method, requestUri);
+
+            mockHandler
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.Is<HttpRequestMessage>(req => req.Method == method && req.RequestUri.ToString() == requestUri), ItExpr.IsAny<System.Threading.CancellationToken>())
+                .ReturnsAsync(new HttpResponseMessage())
+                .Verifiable();
+
+            return mockHandler;
+        }
     }
 }