(maint) Implementing unit tests for language server

Source/chocolatey-language-server.Tests/Validations/AuthorDoesNotMatchMaintainerTests.cs

@@ -0,0 +1,52 @@
+using Chocolatey.Language.Server.Models;
+using Chocolatey.Language.Server.Validations;
+using NUnit.Framework;
+using System.Collections;
+using System.Linq;
+
+namespace Chocolatey.Language.Server.Tests.Validations
+{
+    public class AuthorDoesNotMatchMaintainerTests : ValidationBaseTests<AuthorDoesNotMatchMaintainer>
+    {
+        public override string ExpectedId { get; } = "choco3002";
+
+        public static IEnumerable SameDadaValues
+        {
+            get
+            {
+                yield return new TestCaseData("AdmiringWorm", "AdmiringWorm");
+                yield return new TestCaseData("admiringworm", "AdmiringWorm");
+                yield return new TestCaseData("AdmiringWorm", "admiringworm");
+                yield return new TestCaseData("ADMIRINGWORM", "AdmiringWorm");
+                yield return new TestCaseData("AdmiringWorm", "ADMIRINGWORM");
+            }
+        }
+
+        [TestCaseSource(nameof(SameDadaValues))]
+        public void Should_FailValidationWhenAuthorAndOwnerIsSame(string author, string owner)
+        {
+            var package = new Package
+            {
+                Authors = new MetaValue<string>[] { author },
+                Maintainers = new MetaValue<string>[] { owner }
+            };
+
+            ValidateDiagnosticResult(package, 2);
+        }
+
+        [TestCase("AdmiringWorm", "gep13")]
+        [TestCase("mkevenaar", "steviecoaster")]
+        public void Should_NotFailValidationWhenAuthonAndOwnerIsNotSame(string author, string owner)
+        {
+            var package = new Package
+            {
+                Authors = new MetaValue<string>[] { author },
+                Maintainers = new MetaValue<string>[] { owner }
+            };
+
+            var result = Rule.Validate(package).ToList();
+
+            Assert.That(result, Is.Empty);
+        }
+    }
+}

Source/chocolatey-language-server.Tests/Validations/CopyrightAndAuthorFieldShouldntContainEmailRequirementTests.cs

@@ -0,0 +1,106 @@
+using Chocolatey.Language.Server.Models;
+using Chocolatey.Language.Server.Validations;
+using NUnit.Framework;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Chocolatey.Language.Server.Tests.Validations
+{
+    public class CopyrightAndAuthorFieldShouldntContainEmailRequirementTests : ValidationBaseTests<CopyrightAndAuthorFieldShouldntContainEmailRequirement>
+    {
+        public static IEnumerable FailingAuthors
+        {
+            get
+            {
+                yield return new TestCaseData("[email protected]", null);
+                yield return new TestCaseData("Chocolatey", "[email protected]");
+                yield return new TestCaseData("[email protected]", "[email protected]");
+            }
+        }
+
+        public static IEnumerable FailingCopyrights
+        {
+            get
+            {
+                yield return new TestCaseData("[email protected]");
+            }
+        }
+
+        public override string ExpectedId { get; } = "choco0005";
+
+        [TestCaseSource(nameof(FailingAuthors))]
+        public void Should_FailValidationWhenEmailIsUsedInAuthorField(string author1, string author2)
+        {
+            var authors = new List<MetaValue<string>> { author1 };
+            if (author2 != null) { authors.Add(author2); }
+
+            var package = new Package
+            {
+                Authors = authors,
+                Copyright = string.Empty
+            };
+
+            ValidateDiagnosticResult(package, authors.Count(a => a.Value.Contains('@')));
+        }
+
+        [TestCaseSource(nameof(FailingCopyrights))]
+        public void Should_FailValidationWhenEmailIsUsedInCopyrightField(string copyright)
+        {
+            var package = new Package
+            {
+                Copyright = copyright,
+            };
+
+            ValidateDiagnosticResult(package, 1);
+        }
+
+        [Test]
+        public void Should_NotFailValidationWhenEmailIsNotUsedInAuthors()
+        {
+            var package = new Package
+            {
+                Authors = new MetaValue<string>[] { "Chocolatey", "NuGet" }
+            };
+
+            var result = Rule.Validate(package);
+
+            Assert.That(result, Is.Empty);
+        }
+
+        [Test]
+        public void Should_NotFailValidationWhenEmailIsNotUsedInCopyright()
+        {
+            var package = new Package
+            {
+                Copyright = "Copyright 2016"
+            };
+
+            var result = Rule.Validate(package);
+
+            Assert.That(result, Is.Empty);
+        }
+
+        [Test]
+        public void Should_SetDiagnosticsForAllFoundEmailsInAuthors()
+        {
+            var package = new Package
+            {
+                Authors = new MetaValue<string>[] { "[email protected] [email protected]" }
+            };
+
+            ValidateDiagnosticResult(package, 2);
+        }
+
+        [Test]
+        public void Should_SetDiagnosticsForAllFoundEmailsInCopyright()
+        {
+            var package = new Package
+            {
+                Copyright = "[email protected] something [email protected]"
+            };
+
+            ValidateDiagnosticResult(package, 2);
+        }
+    }
+}

Source/chocolatey-language-server.Tests/Validations/CopyrightWordCountTests.cs

@@ -0,0 +1,46 @@
+using Chocolatey.Language.Server.Models;
+using Chocolatey.Language.Server.Validations;
+using NUnit.Framework;
+
+namespace Chocolatey.Language.Server.Tests.Validations
+{
+    public class CopyrightWordCountTests : ValidationBaseTests<CopyrightWordCount>
+    {
+        public override string ExpectedId { get; } = "choco0006";
+
+        [Test]
+        public void Should_FailValidationWhenCharacterCountIsEqualTo4()
+        {
+            var package = new Package
+            {
+                Copyright = "2020"
+            };
+
+            ValidateDiagnosticResult(package, 1);
+        }
+
+        [Test]
+        public void Should_FailValidationWhenCharacterCountIsLessThan4()
+        {
+            var package = new Package
+            {
+                Copyright = "© m"
+            };
+
+            ValidateDiagnosticResult(package, 1);
+        }
+
+        [Test]
+        public void Should_NotFailValidationWhenCharacterCountIsMoreThan4()
+        {
+            var package = new Package
+            {
+                Copyright = "© 2020"
+            };
+
+            var result = Rule.Validate(package);
+
+            Assert.That(result, Is.Empty);
+        }
+    }
+}

Source/chocolatey-language-server.Tests/Validations/DeprecatedPackagesShouldHaveDependencyTests.cs

@@ -0,0 +1,36 @@
+using Chocolatey.Language.Server.Models;
+using Chocolatey.Language.Server.Validations;
+using NUnit.Framework;
+
+namespace Chocolatey.Language.Server.Tests.Validations
+{
+    public class DeprecatedPackagesShouldHaveDependencyTests : ValidationBaseTests<DeprecatedPackagesShouldHaveDependency>
+    {
+        public override string ExpectedId { get; } = "choco0007";
+
+        [Test]
+        public void Should_FailValidationWhenNoDependencyIsSpecified()
+        {
+            var package = new Package
+            {
+                Title = "[deprecated] Some kind of title"
+            };
+
+            ValidateDiagnosticResult(package, 1);
+        }
+
+        [Test]
+        public void Should_NotFailValidationWhenADependencyIsSpecified()
+        {
+            var package = new Package
+            {
+                Title = "[deprecated] Some kind of title"
+            };
+            package.AddDependency(new Dependency { Id = "some-package-id" });
+
+            var result = Rule.Validate(package);
+
+            Assert.That(result, Is.Empty);
+        }
+    }
+}

Source/chocolatey-language-server.Tests/Validations/DescriptionMaximumWordCountTests.cs

@@ -0,0 +1,37 @@
+using Chocolatey.Language.Server.Models;
+using Chocolatey.Language.Server.Validations;
+using NUnit.Framework;
+
+namespace Chocolatey.Language.Server.Tests.Validations
+{
+    public class DescriptionMaximumWordCountTests : ValidationBaseTests<DescriptionMaximumWordCount>
+    {
+        public override string ExpectedId { get; } = "choco0003";
+
+        [Test]
+        public void Should_FailValidationWhenDescriptionIsLongerThan4000Characters()
+        {
+            var package = new Package
+            {
+                Description = "Hello".PadLeft(4001, 'x'),
+            };
+
+            ValidateDiagnosticResult(package, 1);
+        }
+
+        [TestCase(100)]
+        [TestCase(3990)]
+        [TestCase(4000, TestName = "Should_NotFailValidationWhenDescriptionIsEqualTo4000Characters")]
+        public void Should_NotFailValidationWhenDescriptionIsLessThan4000Characters(int length)
+        {
+            var package = new Package
+            {
+                Description = "Hello".PadLeft(length, 'x')
+            };
+
+            var result = Rule.Validate(package);
+
+            Assert.That(result, Is.Empty);
+        }
+    }
+}

Source/chocolatey-language-server.Tests/Validations/DescriptionMinimumWordCountTests.cs

@@ -0,0 +1,37 @@
+using Chocolatey.Language.Server.Models;
+using Chocolatey.Language.Server.Validations;
+using NUnit.Framework;
+
+namespace Chocolatey.Language.Server.Tests.Validations
+{
+    public class DescriptionMinimumWordCountTests : ValidationBaseTests<DescriptionMinimumWordCount>
+    {
+        public override string ExpectedId { get; } = "choco1001";
+
+        [TestCase(6)]
+        [TestCase(10)]
+        [TestCase(30, TestName = "Should_FailValidationWhenDescriptionIsEqualTo30Characters")]
+        public void Should_FailValidationWhenDescriptionIsLessThan30Characters(int length)
+        {
+            var package = new Package
+            {
+                Description = "Hello".PadLeft(length, 'x')
+            };
+
+            ValidateDiagnosticResult(package, 1);
+        }
+
+        [Test]
+        public void Should_NotFailValidationWhenDescriptionIsMoreThan30Characters()
+        {
+            var package = new Package
+            {
+                Description = "Yo".PadLeft(31, 'x')
+            };
+
+            var result = Rule.Validate(package);
+
+            Assert.That(result, Is.Empty);
+        }
+    }
+}

Source/chocolatey-language-server.Tests/Validations/DescriptionRequiredValidationTests.cs

@@ -0,0 +1,37 @@
+using Chocolatey.Language.Server.Models;
+using Chocolatey.Language.Server.Validations;
+using NUnit.Framework;
+
+namespace Chocolatey.Language.Server.Tests.Validations
+{
+    public class DescriptionRequiredValidationTests : ValidationBaseTests<DescriptionRequiredValidation>
+    {
+        public override string ExpectedId { get; } = "choco0002";
+
+        [TestCase(null)]
+        [TestCase("")]
+        [TestCase("                   ")]
+        public void Should_FailValidationWhenDescriptionIsNullOrWhitespace(string value)
+        {
+            var package = new Package
+            {
+                Description = value
+            };
+
+            ValidateDiagnosticResult(package, 1);
+        }
+
+        [Test]
+        public void Should_NotFailValidationWhenDescriptionHaveText()
+        {
+            var package = new Package
+            {
+                Description = "My new awesome package description"
+            };
+
+            var result = Rule.Validate(package);
+
+            Assert.That(result, Is.Empty);
+        }
+    }
+}