From 43e997570870b2a7a0e98dc06170799a34d7faba Mon Sep 17 00:00:00 2001 From: vamsi polavarapu Date: Mon, 13 Oct 2025 12:12:26 -0700 Subject: [PATCH 1/5] Committing changes related XML suppressions not working (https://github.com/microsoft/DevSkim/issues/588). Changes: - Added xml suppression comments syntax requirements in comments.json - Added a test class for testing suppression comments. File: DevSkimRuleProcessorTests.cs --- .../DevSkimRuleProcessorTests.cs | 170 ++++++++++++++++++ .../Microsoft.DevSkim/resources/comments.json | 10 +- 2 files changed, 179 insertions(+), 1 deletion(-) create mode 100644 DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs diff --git a/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs b/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs new file mode 100644 index 00000000..6a312338 --- /dev/null +++ b/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs @@ -0,0 +1,170 @@ +namespace Microsoft.DevSkim.Tests +{ + [TestClass] + public class DevSkimRuleProcessorTests + { + [TestMethod] + public void GenerateSuppressionByLanguage() + { + var languages = DevSkimLanguages.LoadEmbedded(); + + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_BasicSuppression() + { + // Test basic suppression generation for C# (inline comment style) + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456"); + + Assert.AreEqual("// DevSkim: ignore DS123456", result); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_WithDuration() + { + // Test suppression with expiration date + DateTime testDate = DateTime.Now.AddDays(30); + string expectedDate = testDate.ToString("yyyy-MM-dd"); + + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", duration: 30); + + Assert.IsTrue(result.Contains("until")); + Assert.IsTrue(result.Contains(expectedDate)); + Assert.IsTrue(result.StartsWith("// DevSkim: ignore DS123456 until")); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_WithReviewer() + { + // Test suppression with reviewer name + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", reviewerName: "JohnDoe"); + + Assert.AreEqual("// DevSkim: ignore DS123456 by JohnDoe", result); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_WithDurationAndReviewer() + { + // Test suppression with both duration and reviewer + DateTime testDate = DateTime.Now.AddDays(15); + string expectedDate = testDate.ToString("yyyy-MM-dd"); + + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", duration: 15, reviewerName: "JaneSmith"); + + Assert.IsTrue(result.Contains($"until {expectedDate}")); + Assert.IsTrue(result.Contains("by JaneSmith")); + Assert.IsTrue(result.StartsWith("// DevSkim: ignore DS123456 until")); + Assert.IsTrue(result.EndsWith(" by JaneSmith")); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_MultiLinePreferred() + { + // Test multiline comment preference for C# + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", preferMultiLine: true); + + Assert.IsTrue(result.StartsWith("/* DevSkim: ignore DS123456")); + Assert.IsTrue(result.EndsWith(" */")); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_PythonLanguage() + { + // Test Python-style comments + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("python", "DS123456"); + + Assert.AreEqual("# DevSkim: ignore DS123456", result); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_PythonMultiLine() + { + // Test Python multiline (should use prefix/suffix style) + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("python", "DS123456", preferMultiLine: true); + + // Python uses # as both inline and prefix, with \n as suffix for multiline + Assert.IsTrue(result.StartsWith("# DevSkim: ignore DS123456")); + Assert.IsTrue(result.EndsWith("\n")); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_SQLLanguage() + { + // Test SQL-style comments + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("sql", "DS123456"); + + Assert.AreEqual("-- DevSkim: ignore DS123456", result); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_MultipleRuleIds() + { + // Test suppression with multiple rule IDs + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456,DS789012"); + + Assert.AreEqual("// DevSkim: ignore DS123456,DS789012", result); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_UnsupportedLanguage() + { + // Test with a language that doesn't have comment configuration + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("unknownlang", "DS123456"); + + // Should return empty string or basic format depending on implementation + Assert.IsNotNull(result); + // The method should handle unknown languages gracefully + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_EmptyRuleId() + { + // Test with empty rule ID + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", ""); + + Assert.AreEqual("// DevSkim: ignore ", result); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_VBLanguage() + { + // Test Visual Basic style comments + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("vb", "DS123456"); + + Assert.AreEqual("' DevSkim: ignore DS123456", result); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_XMLLanguage() + { + // Test XML language + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("xml", "DS123456"); + + Console.WriteLine($"XML suppression result: '{result}'"); + Assert.AreEqual("", result); + + // This test documents the current behavior for XML + Assert.IsNotNull(result); + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_NullLanguage() + { + // Test with null language parameter + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(null, "DS123456"); + + Assert.IsNotNull(result); + // Should handle null gracefully + } + + [TestMethod] + public void GenerateSuppressionByLanguageTest_CustomLanguagesObject() + { + // Test with custom languages object + var customLanguages = DevSkimLanguages.LoadEmbedded(); + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", languages: customLanguages); + + Assert.AreEqual("// DevSkim: ignore DS123456", result); + } + } +} diff --git a/DevSkim-DotNet/Microsoft.DevSkim/resources/comments.json b/DevSkim-DotNet/Microsoft.DevSkim/resources/comments.json index e892c1dd..238c9f19 100644 --- a/DevSkim-DotNet/Microsoft.DevSkim/resources/comments.json +++ b/DevSkim-DotNet/Microsoft.DevSkim/resources/comments.json @@ -25,7 +25,7 @@ "language": [ "plaintext" ], - "always": true + "always": true }, { "language": [ @@ -74,5 +74,13 @@ "inline": "::", "prefix": "Rem", "suffix": "\n" + }, + { + "language": [ + "xml" + ], + "inline": "", + "prefix": "" } ] \ No newline at end of file From 325a1fc965c4fbf6d8e3fcf7778fff0c0802098f Mon Sep 17 00:00:00 2001 From: vamsi polavarapu Date: Tue, 21 Oct 2025 15:46:09 -0700 Subject: [PATCH 2/5] New integration tests for XML suppressions --- .../DevSkimRuleProcessorTests.cs | 112 ++++------------- .../SuppressionsTest.cs | 114 ++++++++++++++++++ .../Microsoft.DevSkim/resources/comments.json | 1 - 3 files changed, 140 insertions(+), 87 deletions(-) diff --git a/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs b/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs index 6a312338..da5c2437 100644 --- a/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs +++ b/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs @@ -7,16 +7,20 @@ public class DevSkimRuleProcessorTests public void GenerateSuppressionByLanguage() { var languages = DevSkimLanguages.LoadEmbedded(); - } - [TestMethod] - public void GenerateSuppressionByLanguageTest_BasicSuppression() + [DataTestMethod] + [DataRow("csharp", "DS123456", "// DevSkim: ignore DS123456", DisplayName = "C# Basic Suppression")] + [DataRow("python", "DS123456", "# DevSkim: ignore DS123456", DisplayName = "Python Basic Suppression")] + [DataRow("sql", "DS123456", "-- DevSkim: ignore DS123456", DisplayName = "SQL Basic Suppression")] + [DataRow("vb", "DS123456", "' DevSkim: ignore DS123456", DisplayName = "VB Basic Suppression")] + [DataRow("csharp", "DS123456,DS789012", "// DevSkim: ignore DS123456,DS789012", DisplayName = "Multiple Rule IDs")] + [DataRow("csharp", "", "// DevSkim: ignore ", DisplayName = "Empty Rule ID")] + public void GenerateSuppressionByLanguageTest_BasicSuppressions(string language, string ruleId, string expected) { - // Test basic suppression generation for C# (inline comment style) - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456"); - - Assert.AreEqual("// DevSkim: ignore DS123456", result); + // Test basic suppression generation for various languages + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(language, ruleId); + Assert.AreEqual(expected, result); } [TestMethod] @@ -57,81 +61,16 @@ public void GenerateSuppressionByLanguageTest_WithDurationAndReviewer() Assert.IsTrue(result.EndsWith(" by JaneSmith")); } - [TestMethod] - public void GenerateSuppressionByLanguageTest_MultiLinePreferred() - { - // Test multiline comment preference for C# - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", preferMultiLine: true); - - Assert.IsTrue(result.StartsWith("/* DevSkim: ignore DS123456")); - Assert.IsTrue(result.EndsWith(" */")); - } - - [TestMethod] - public void GenerateSuppressionByLanguageTest_PythonLanguage() - { - // Test Python-style comments - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("python", "DS123456"); - - Assert.AreEqual("# DevSkim: ignore DS123456", result); - } - - [TestMethod] - public void GenerateSuppressionByLanguageTest_PythonMultiLine() - { - // Test Python multiline (should use prefix/suffix style) - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("python", "DS123456", preferMultiLine: true); - - // Python uses # as both inline and prefix, with \n as suffix for multiline - Assert.IsTrue(result.StartsWith("# DevSkim: ignore DS123456")); - Assert.IsTrue(result.EndsWith("\n")); - } - - [TestMethod] - public void GenerateSuppressionByLanguageTest_SQLLanguage() - { - // Test SQL-style comments - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("sql", "DS123456"); - - Assert.AreEqual("-- DevSkim: ignore DS123456", result); - } - - [TestMethod] - public void GenerateSuppressionByLanguageTest_MultipleRuleIds() + [DataTestMethod] + [DataRow("csharp", "DS123456", "/*", " */", DisplayName = "C# Multiline")] + [DataRow("python", "DS123456", "#", "\n", DisplayName = "Python Multiline")] + public void GenerateSuppressionByLanguageTest_MultiLinePreferred(string language, string ruleId, string expectedStart, string expectedEnd) { - // Test suppression with multiple rule IDs - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456,DS789012"); + // Test multiline comment preference + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(language, ruleId, preferMultiLine: true); - Assert.AreEqual("// DevSkim: ignore DS123456,DS789012", result); - } - - [TestMethod] - public void GenerateSuppressionByLanguageTest_UnsupportedLanguage() - { - // Test with a language that doesn't have comment configuration - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("unknownlang", "DS123456"); - - // Should return empty string or basic format depending on implementation - Assert.IsNotNull(result); - // The method should handle unknown languages gracefully - } - - [TestMethod] - public void GenerateSuppressionByLanguageTest_EmptyRuleId() - { - // Test with empty rule ID - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", ""); - - Assert.AreEqual("// DevSkim: ignore ", result); - } - - [TestMethod] - public void GenerateSuppressionByLanguageTest_VBLanguage() - { - // Test Visual Basic style comments - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("vb", "DS123456"); - - Assert.AreEqual("' DevSkim: ignore DS123456", result); + Assert.IsTrue(result.StartsWith($"{expectedStart} DevSkim: ignore {ruleId}")); + Assert.IsTrue(result.EndsWith(expectedEnd)); } [TestMethod] @@ -143,18 +82,19 @@ public void GenerateSuppressionByLanguageTest_XMLLanguage() Console.WriteLine($"XML suppression result: '{result}'"); Assert.AreEqual("", result); - // This test documents the current behavior for XML Assert.IsNotNull(result); } - [TestMethod] - public void GenerateSuppressionByLanguageTest_NullLanguage() + [DataTestMethod] + [DataRow(null, DisplayName = "Null Language")] + [DataRow("unknownlang", DisplayName = "Unknown Language")] + public void GenerateSuppressionByLanguageTest_InvalidLanguages(string language) { - // Test with null language parameter - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(null, "DS123456"); + // Test with invalid language parameters + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(language, "DS123456"); Assert.IsNotNull(result); - // Should handle null gracefully + // Should handle invalid languages gracefully } [TestMethod] diff --git a/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs b/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs index 9d7cc85d..284cab39 100644 --- a/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs +++ b/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs @@ -11,6 +11,8 @@ namespace Microsoft.DevSkim.Tests [TestClass] public class SuppressionTest { + public TestContext? TestContext { get; set; } + [DataTestMethod] [DataRow("", 30)] [DataRow("Contoso", 30)] @@ -343,5 +345,117 @@ public void DontChangeFilesWithoutSelectedFindings(string lineBreakSequence, boo string result = File.ReadAllText(sourceFile); Assert.AreEqual(originalContent, result); } + + /// + /// Integration test for XML suppressions + /// + [TestMethod] + public void ExecuteSuppressionsForXML() + { + // Properly formatted XML content with patterns that trigger DevSkim rules (MD5 and http://) + string xmlContent = @" + + + MD5 + + http://example.com +"; + + (string basePath, string sourceFile, string sarifPath) = runAnalysis(xmlContent, "xml"); + + SuppressionCommandOptions opts = new SuppressionCommandOptions + { + Path = basePath, + SarifInput = sarifPath, + ApplyAllSuppression = true + }; + + int resultCode = new SuppressionCommand(opts).Run(); + Assert.AreEqual(0, resultCode); + + string result = File.ReadAllText(sourceFile); + + // Verify that XML-style suppressions were added + Assert.Contains("", result, "XML suppression comment should be properly closed"); + + // Verify suppressions are in correct format + string[] lines = File.ReadAllLines(sourceFile); + bool foundSuppression = false; + foreach (string line in lines) + { + if (line.Contains("" } From 09fd8e7ee234e0c4ac95db45453290103c46093d Mon Sep 17 00:00:00 2001 From: vamsi polavarapu Date: Tue, 21 Oct 2025 16:58:39 -0700 Subject: [PATCH 3/5] Refactored the tests in DevSkimRuleProcessorTests.cs file --- .../DevSkimRuleProcessorTests.cs | 65 ++++++++++++------- 1 file changed, 40 insertions(+), 25 deletions(-) diff --git a/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs b/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs index da5c2437..dd41c5c6 100644 --- a/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs +++ b/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs @@ -9,7 +9,7 @@ public void GenerateSuppressionByLanguage() var languages = DevSkimLanguages.LoadEmbedded(); } - [DataTestMethod] + [TestMethod] [DataRow("csharp", "DS123456", "// DevSkim: ignore DS123456", DisplayName = "C# Basic Suppression")] [DataRow("python", "DS123456", "# DevSkim: ignore DS123456", DisplayName = "Python Basic Suppression")] [DataRow("sql", "DS123456", "-- DevSkim: ignore DS123456", DisplayName = "SQL Basic Suppression")] @@ -24,44 +24,56 @@ public void GenerateSuppressionByLanguageTest_BasicSuppressions(string language, } [TestMethod] - public void GenerateSuppressionByLanguageTest_WithDuration() + [DataRow("csharp", "DS123456", 30, DisplayName = "C# with 30 days duration")] + [DataRow("python", "DS789012", 15, DisplayName = "Python with 15 days duration")] + [DataRow("sql", "DS111213", 60, DisplayName = "SQL with 60 days duration")] + [DataRow("vb", "DS141516", 7, DisplayName = "VB with 7 days duration")] + public void GenerateSuppressionByLanguageTest_WithDuration(string language, string ruleId, int duration) { // Test suppression with expiration date - DateTime testDate = DateTime.Now.AddDays(30); + DateTime testDate = DateTime.Now.AddDays(duration); string expectedDate = testDate.ToString("yyyy-MM-dd"); - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", duration: 30); + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(language, ruleId, duration: duration); Assert.IsTrue(result.Contains("until")); Assert.IsTrue(result.Contains(expectedDate)); - Assert.IsTrue(result.StartsWith("// DevSkim: ignore DS123456 until")); + Assert.IsTrue(result.Contains($"ignore {ruleId} until")); } [TestMethod] - public void GenerateSuppressionByLanguageTest_WithReviewer() + [DataRow("csharp", "DS123456", "JohnDoe", "// DevSkim: ignore DS123456 by JohnDoe", DisplayName = "C# with reviewer")] + [DataRow("python", "DS789012", "JaneSmith", "# DevSkim: ignore DS789012 by JaneSmith", DisplayName = "Python with reviewer")] + [DataRow("sql", "DS111213", "BobJones", "-- DevSkim: ignore DS111213 by BobJones", DisplayName = "SQL with reviewer")] + [DataRow("vb", "DS141516", "AliceWilliams", "' DevSkim: ignore DS141516 by AliceWilliams", DisplayName = "VB with reviewer")] + public void GenerateSuppressionByLanguageTest_WithReviewer(string language, string ruleId, string reviewerName, string expected) { // Test suppression with reviewer name - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", reviewerName: "JohnDoe"); + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(language, ruleId, reviewerName: reviewerName); - Assert.AreEqual("// DevSkim: ignore DS123456 by JohnDoe", result); + Assert.AreEqual(expected, result); } [TestMethod] - public void GenerateSuppressionByLanguageTest_WithDurationAndReviewer() + [DataRow("csharp", "DS123456", 15, "JaneSmith", DisplayName = "C# with duration and reviewer")] + [DataRow("python", "DS789012", 30, "JohnDoe", DisplayName = "Python with duration and reviewer")] + [DataRow("sql", "DS111213", 7, "BobJones", DisplayName = "SQL with duration and reviewer")] + [DataRow("vb", "DS141516", 45, "AliceWilliams", DisplayName = "VB with duration and reviewer")] + public void GenerateSuppressionByLanguageTest_WithDurationAndReviewer(string language, string ruleId, int duration, string reviewerName) { // Test suppression with both duration and reviewer - DateTime testDate = DateTime.Now.AddDays(15); + DateTime testDate = DateTime.Now.AddDays(duration); string expectedDate = testDate.ToString("yyyy-MM-dd"); - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", duration: 15, reviewerName: "JaneSmith"); + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(language, ruleId, duration: duration, reviewerName: reviewerName); Assert.IsTrue(result.Contains($"until {expectedDate}")); - Assert.IsTrue(result.Contains("by JaneSmith")); - Assert.IsTrue(result.StartsWith("// DevSkim: ignore DS123456 until")); - Assert.IsTrue(result.EndsWith(" by JaneSmith")); + Assert.IsTrue(result.Contains($"by {reviewerName}")); + Assert.IsTrue(result.Contains($"ignore {ruleId} until")); + Assert.IsTrue(result.EndsWith($" by {reviewerName}")); } - [DataTestMethod] + [TestMethod] [DataRow("csharp", "DS123456", "/*", " */", DisplayName = "C# Multiline")] [DataRow("python", "DS123456", "#", "\n", DisplayName = "Python Multiline")] public void GenerateSuppressionByLanguageTest_MultiLinePreferred(string language, string ruleId, string expectedStart, string expectedEnd) @@ -74,18 +86,18 @@ public void GenerateSuppressionByLanguageTest_MultiLinePreferred(string language } [TestMethod] - public void GenerateSuppressionByLanguageTest_XMLLanguage() + [DataRow("xml", "DS123456", "", DisplayName = "XML Language")] + public void GenerateSuppressionByLanguageTest_XMLLanguage(string language, string ruleId, string expected) { - // Test XML language - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("xml", "DS123456"); - - Console.WriteLine($"XML suppression result: '{result}'"); - Assert.AreEqual("", result); + // Test XML-like languages + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(language, ruleId); + Console.WriteLine($"{language} suppression result: '{result}'"); + Assert.AreEqual(expected, result); Assert.IsNotNull(result); } - [DataTestMethod] + [TestMethod] [DataRow(null, DisplayName = "Null Language")] [DataRow("unknownlang", DisplayName = "Unknown Language")] public void GenerateSuppressionByLanguageTest_InvalidLanguages(string language) @@ -98,13 +110,16 @@ public void GenerateSuppressionByLanguageTest_InvalidLanguages(string language) } [TestMethod] - public void GenerateSuppressionByLanguageTest_CustomLanguagesObject() + [DataRow("csharp", "DS123456", "// DevSkim: ignore DS123456", DisplayName = "C# with custom languages")] + [DataRow("python", "DS789012", "# DevSkim: ignore DS789012", DisplayName = "Python with custom languages")] + [DataRow("sql", "DS111213", "-- DevSkim: ignore DS111213", DisplayName = "SQL with custom languages")] + public void GenerateSuppressionByLanguageTest_CustomLanguagesObject(string language, string ruleId, string expected) { // Test with custom languages object var customLanguages = DevSkimLanguages.LoadEmbedded(); - string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage("csharp", "DS123456", languages: customLanguages); + string result = DevSkimRuleProcessor.GenerateSuppressionByLanguage(language, ruleId, languages: customLanguages); - Assert.AreEqual("// DevSkim: ignore DS123456", result); + Assert.AreEqual(expected, result); } } } From 0e6135cba4ec25e804c29d4665343b965cbfb158 Mon Sep 17 00:00:00 2001 From: vamsi polavarapu Date: Wed, 22 Oct 2025 12:00:07 -0700 Subject: [PATCH 4/5] Cleaned up the unused method GenerateSuppressionByLanguage from the DevSkimRuleProcessorTests --- .../Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs b/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs index dd41c5c6..e876a4fe 100644 --- a/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs +++ b/DevSkim-DotNet/Microsoft.DevSkim.Tests/DevSkimRuleProcessorTests.cs @@ -3,11 +3,6 @@ [TestClass] public class DevSkimRuleProcessorTests { - [TestMethod] - public void GenerateSuppressionByLanguage() - { - var languages = DevSkimLanguages.LoadEmbedded(); - } [TestMethod] [DataRow("csharp", "DS123456", "// DevSkim: ignore DS123456", DisplayName = "C# Basic Suppression")] From 2004e3f7913eeb0165c682bbfe6e4eaca1dd8334 Mon Sep 17 00:00:00 2001 From: Vamsi Polavarapu Date: Wed, 22 Oct 2025 14:17:50 -0700 Subject: [PATCH 5/5] Update Changelog for version 1.0.67 Enabling suppressions for XML files to address bug #588. --- Changelog.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Changelog.md b/Changelog.md index ece71d6f..c3bf10a6 100644 --- a/Changelog.md +++ b/Changelog.md @@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.0.67] - 2025-10-22 +### Fix +Enabling suppressions for XML files (addressing bug [#588](https://github.com/microsoft/DevSkim/issues/588)) + ## [1.0.66] - 2025-09-04 ### Dependencies Update Dependencies for C# Projects