Added unit test to check order of operations for Save File.

Added GitHub SourceCode URL

Author: janstaelensskyline

CICD.Tools.GitHubToCatalogYamlTests/CatalogManagerTests.cs

@@ -16,6 +16,8 @@
     using Skyline.DataMiner.CICD.FileSystem;
     using Skyline.DataMiner.CICD.Tools.GitHubToCatalogYaml;
 
+    using YamlDotNet.Serialization;
+
     [TestClass]
     public class CatalogManagerTests
     {
@@ -454,5 +456,66 @@ public async Task ProcessCatalogYamlAsync_ShouldUseCatalogYmlOverManifestWhenBot
             // Assert
             mockFileSystem.Verify(fs => fs.File.WriteAllText(catalogFilePath, It.Is<string>(s => s.Contains("short_description: from catalog"))), Times.Once);
         }
+
+        [TestMethod]
+        public async Task ProcessCatalogYamlAsync_SaveFileShouldAccessFileSystemInCorrectOrderForBothFiles()
+        {
+            // Arrange
+            var repoName = "SLC-AS-testRepo";
+            var expectedCatalogPath = "testWorkspace/catalog.yml";
+            var expectedAutoGenPath = "testWorkspace/.githubtocatalog/auto-generated-catalog.yml";
+            var manifestYamlContent = "id: manifestId\nshort_description: from manifest";
+
+            // Simulate the YAML serialization
+            mockFileSystem.Setup(fs => fs.File.ReadAllText(manifestFilePath)).Returns(manifestYamlContent);
+            // Setup mocks for file system interactions
+            var mockSequence = new MockSequence();
+
+            // Ensure the operations for 'catalog.yml' happen in sequence
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.File.DeleteFile(expectedCatalogPath));
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.Path.GetDirectoryName(expectedCatalogPath))
+                .Returns("testDirectory");
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.Directory.CreateDirectory("testDirectory"));
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.Directory.TryAllowWritesOnDirectory("testDirectory"))
+                .Returns(true);
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.File.WriteAllText(expectedCatalogPath, It.IsAny<String>()));
+
+            // Ensure the operations for 'auto-generated-catalog.yml' happen in sequence
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.File.DeleteFile(expectedAutoGenPath));
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.Path.GetDirectoryName(expectedAutoGenPath))
+                .Returns("testAutoGenDirectory");
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.Directory.CreateDirectory("testAutoGenDirectory"));
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.Directory.TryAllowWritesOnDirectory("testAutoGenDirectory"))
+                .Returns(true);
+            mockFileSystem.InSequence(mockSequence)
+                .Setup(fs => fs.File.WriteAllText(expectedAutoGenPath, It.IsAny<String>()));
+
+            // Act
+            await catalogManager.ProcessCatalogYamlAsync(repoName);
+
+            // Assert
+            // Verify that the catalog.yml file system interactions occurred in the correct order
+            mockFileSystem.Verify(fs => fs.File.DeleteFile(expectedCatalogPath), Times.Once);
+            mockFileSystem.Verify(fs => fs.Path.GetDirectoryName(expectedCatalogPath), Times.Once);
+            mockFileSystem.Verify(fs => fs.Directory.CreateDirectory("testDirectory"), Times.Once);
+            mockFileSystem.Verify(fs => fs.Directory.TryAllowWritesOnDirectory("testDirectory"), Times.Once);
+            mockFileSystem.Verify(fs => fs.File.WriteAllText(expectedCatalogPath, It.IsAny<String>()), Times.Once);
+
+            // Verify that the auto-generated-catalog.yml file system interactions occurred in the correct order
+            mockFileSystem.Verify(fs => fs.File.DeleteFile(expectedAutoGenPath), Times.Once);
+            mockFileSystem.Verify(fs => fs.Path.GetDirectoryName(expectedAutoGenPath), Times.Once);
+            mockFileSystem.Verify(fs => fs.Directory.CreateDirectory("testAutoGenDirectory"), Times.Once);
+            mockFileSystem.Verify(fs => fs.Directory.TryAllowWritesOnDirectory("testAutoGenDirectory"), Times.Once);
+            mockFileSystem.Verify(fs => fs.File.WriteAllText(expectedAutoGenPath, It.IsAny<String>()), Times.Once);
+        }
     }
 }

Skyline.DataMiner.CICD.Tools.GitHubToCatalogYaml/CatalogManager.cs

@@ -34,6 +34,7 @@ public CatalogManager(IFileSystem fs, ILogger logger, IGitHubService service, st
             this.service = service;
             this.workspace = workspace;
         }
+
         /// <summary>
         /// Processes the catalog YAML file for the specified GitHub repository. It checks and updates various fields such as ID, description, tags, title, and type.
         /// If no catalog file is found, it attempts to create one from the manifest file.
@@ -84,7 +85,24 @@ public async Task ProcessCatalogYamlAsync(string repoName, string catalogIdentif
         }
 
         /// <summary>
-        /// Checks and sets the ID field in the provided catalog YAML. 
+        /// Infers the artifact content type based on the provided keyword. It checks if the keyword is in the artifact type map and returns the corresponding content type.
+        /// </summary>
+        /// <param name="keyword">The keyword to infer the artifact content type from.</param>
+        /// <returns>The inferred content type, or an empty string if the keyword is not recognized.</returns>
+        private static string InferArtifactContentType(string keyword)
+        {
+            // Check if the keyword exists in the dictionary
+            if (Constants.ArtifactTypeMap.TryGetValue(keyword.ToUpper(), out var contentType))
+            {
+                return contentType;
+            }
+
+            return Constants.ArtifactTypeMap.FirstOrDefault(pair => pair.Value.Equals(keyword, StringComparison.OrdinalIgnoreCase)).Value ??
+                   String.Empty;
+        }
+
+        /// <summary>
+        /// Checks and sets the ID field in the provided catalog YAML.
         /// If the ID is not present or is empty, it attempts to retrieve or create a new ID using the provided catalog identifier, or the ID from the auto-generated catalog YAML.
         /// </summary>
         /// <param name="catalogYaml">The catalog YAML object to check and update.</param>
@@ -134,7 +152,7 @@ private async Task CheckShortDescription(CatalogYaml catalogYaml)
         }
 
         /// <summary>
-        /// Checks and sets the SourceCodeUrl field in the provided catalog YAML. 
+        /// Checks and sets the SourceCodeUrl field in the provided catalog YAML.
         /// If the SourceCodeUrl is not present or is empty, it assigns a GitHub repository URL based on the provided repository name.
         /// </summary>
         /// <param name="catalogYaml">The catalog YAML object to check and update.</param>
@@ -242,29 +260,20 @@ private void CheckType(CatalogYaml catalogYaml, CleanTitle parsedRepoName)
         /// <param name="deserializer">The YAML deserializer to parse the existing YAML file.</param>
         /// <param name="foundFile">The path to the found YAML file, or null if no file is found.</param>
         /// <returns>The deserialized <see cref="CatalogYaml"/> object, or a new object if no file is found.</returns>
-        private CatalogYaml CreateCatalogYaml(IDeserializer deserializer, out string foundFile)
+        private CatalogYaml CreateAutoGeneratedCatalogYaml(IDeserializer deserializer, out string foundFile)
         {
-            logger.LogDebug("Checking if user has provided a catalog.yml or manifest.yml file within the workspace root.");
+            logger.LogDebug("Checking if ");
             foundFile = null;
 
-            string filePath = fs.Path.Combine(workspace, "catalog.yml");
+            string filePath = fs.Path.Combine(workspace, ".githubtocatalog", "auto-generated-catalog.yml");
             if (!fs.File.Exists(filePath))
             {
-                filePath = fs.Path.Combine(workspace, "manifest.yml");
-                if (!fs.File.Exists(filePath))
-                {
-                    logger.LogDebug("No existing configuration file found.");
-                }
-                else
-                {
-                    foundFile = filePath;
-                    logger.LogDebug($"Found file at: {filePath}");
-                }
+                logger.LogDebug("No existing auto-generated configuration file found.");
             }
             else
             {
                 foundFile = filePath;
-                logger.LogDebug($"Found file at: {filePath}");
+                logger.LogDebug($"Found auto-generated file at: {filePath}");
             }
 
             if (String.IsNullOrWhiteSpace(foundFile))
@@ -284,20 +293,29 @@ private CatalogYaml CreateCatalogYaml(IDeserializer deserializer, out string fou
         /// <param name="deserializer">The YAML deserializer to parse the existing YAML file.</param>
         /// <param name="foundFile">The path to the found YAML file, or null if no file is found.</param>
         /// <returns>The deserialized <see cref="CatalogYaml"/> object, or a new object if no file is found.</returns>
-        private CatalogYaml CreateAutoGeneratedCatalogYaml(IDeserializer deserializer, out string foundFile)
+        private CatalogYaml CreateCatalogYaml(IDeserializer deserializer, out string foundFile)
         {
-            logger.LogDebug("Checking if ");
+            logger.LogDebug("Checking if user has provided a catalog.yml or manifest.yml file within the workspace root.");
             foundFile = null;
 
-            string filePath = fs.Path.Combine(workspace, ".githubtocatalog", "auto-generated-catalog.yml");
+            string filePath = fs.Path.Combine(workspace, "catalog.yml");
             if (!fs.File.Exists(filePath))
             {
-                logger.LogDebug("No existing auto-generated configuration file found.");
+                filePath = fs.Path.Combine(workspace, "manifest.yml");
+                if (!fs.File.Exists(filePath))
+                {
+                    logger.LogDebug("No existing configuration file found.");
+                }
+                else
+                {
+                    foundFile = filePath;
+                    logger.LogDebug($"Found file at: {filePath}");
+                }
             }
             else
             {
                 foundFile = filePath;
-                logger.LogDebug($"Found auto-generated file at: {filePath}");
+                logger.LogDebug($"Found file at: {filePath}");
             }
 
             if (String.IsNullOrWhiteSpace(foundFile))
@@ -310,24 +328,6 @@ private CatalogYaml CreateAutoGeneratedCatalogYaml(IDeserializer deserializer, o
             return deserializer.Deserialize<CatalogYaml>(yamlContent) ?? new CatalogYaml();
         }
 
-
-        /// <summary>
-        /// Infers the artifact content type based on the provided keyword. It checks if the keyword is in the artifact type map and returns the corresponding content type.
-        /// </summary>
-        /// <param name="keyword">The keyword to infer the artifact content type from.</param>
-        /// <returns>The inferred content type, or an empty string if the keyword is not recognized.</returns>
-        private static string InferArtifactContentType(string keyword)
-        {
-            // Check if the keyword exists in the dictionary
-            if (Constants.ArtifactTypeMap.TryGetValue(keyword.ToUpper(), out var contentType))
-            {
-                return contentType;
-            }
-
-            return Constants.ArtifactTypeMap.FirstOrDefault(pair => pair.Value.Equals(keyword, StringComparison.OrdinalIgnoreCase)).Value ??
-                   String.Empty;
-        }
-
         /// <summary>
         /// Serializes the catalog YAML object and saves it to the specified output path.
         /// </summary>