Optimize Unit Tests

Author: tinohager

src/Nager.PublicSuffix.UnitTest/DomainNormalizerTest.cs

@@ -11,7 +11,7 @@ public class DomainNormalizerTest
         [DataRow("HTTPS://microsoft.com")]
         [DataRow("HTTPS://Microsoft.com")]
         [DataRow("HTTPS://MICROSOFT.COM")]
-        [DataTestMethod]
+        [TestMethod]
         public void UriDomainNormalizerTest(string domain)
         {
             var domainNormalizer = new UriDomainNormalizer();
@@ -26,7 +26,7 @@ public void UriDomainNormalizerTest(string domain)
 
         [DataRow("xn--frisr-mua.com")]
         [DataRow("XN--frisr-mua.com")]
-        [DataTestMethod]
+        [TestMethod]
         public void IdnMappingDomainNormalizerTest(string domain)
         {
             var domainNormalizer = new IdnMappingDomainNormalizer();

src/Nager.PublicSuffix.UnitTest/NormalizationVariationTest.cs

@@ -52,14 +52,13 @@ public void UnderscoreBasedVariationsValid()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ParseException))]
         public void UnderscoreBasedVariationsInvalid()
         {
             // These domains are treated as invalid and produce null via the Uri normalization method.
             // def._ghi.jkl.com is valid but
             // abc.def._ghi.jkl.com is invalid.
             // It can't be correct that adding abc. in front of a valid domain makes it invalid
-            this.PerformParsingCheck("abc.def._ghi.jkl.com", null, "jkl.com");
+            Assert.ThrowsExactly<ParseException>(() => this.PerformParsingCheck("abc.def._ghi.jkl.com", null, "jkl.com"));
         }
 
         [TestMethod]
@@ -96,17 +95,16 @@ public void DashBasedVariationsValid()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ParseException))]
         public void DashBasedVariationsInvalid()
         {
             // Adding sub domains to these examples demonstrates how the Uri validation behaves in an unexpected way.
             // For example "sub.-example.com" is valid but "double.sub.-example.com" is not.
 
-            this.PerformParsingCheck("sub.example.-com", null, "example.-com");
-            this.PerformParsingCheck("sub.example.-com-", null, "example.-com-");
-            this.PerformParsingCheck("double.sub.-example.com", null, "-example.com");
-            this.PerformParsingCheck("double.sub.example.-com", null, "example.-com");
-            this.PerformParsingCheck("double.sub.example.-com-", null, "example.-com-");
+            Assert.ThrowsExactly<ParseException>(() => this.PerformParsingCheck("sub.example.-com", null, "example.-com"));
+            Assert.ThrowsExactly<ParseException>(() => this.PerformParsingCheck("sub.example.-com-", null, "example.-com-"));
+            Assert.ThrowsExactly<ParseException>(() => this.PerformParsingCheck("double.sub.-example.com", null, "-example.com"));
+            Assert.ThrowsExactly<ParseException>(() => this.PerformParsingCheck("double.sub.example.-com", null, "example.-com"));
+            Assert.ThrowsExactly<ParseException>(() => this.PerformParsingCheck("double.sub.example.-com-", null, "example.-com-"));
         }
 
         private void PerformParsingCheck(string domain, string expectedRegistrableDomain_UriVersion, string expectedRegistrableDomain_IdnVersion)

src/Nager.PublicSuffix.UnitTest/RealRules/PublicSuffixTest.cs

@@ -25,26 +25,25 @@ protected void CheckPublicSuffix(string domain, string expected)
             }
         }
 
-        [DataTestMethod]
         [DataRow(null)]
+        [TestMethod]
         public void ParseNullDomainCheck(string domain)
         {
             this.CheckPublicSuffix(domain, null);
         }
 
-        [DataTestMethod]
         [DataRow(".com")]
         [DataRow(".example")]
         [DataRow(".example.com")]
         [DataRow(".example.example")]
-        [ExpectedException(typeof(ParseException))]
+        [TestMethod]
         public void ParseInvalidDomainCheck(string domain)
         {
-            this.CheckPublicSuffix(domain, null);
+            Assert.ThrowsExactly<ParseException>(() => this.CheckPublicSuffix(domain, null));
         }
 
-        [DataTestMethod]
         [DataRow("example")]
+        [TestMethod]
         public void ParseNotUsedTopLevelDomain_(string domain)
         {
             this.CheckPublicSuffix(domain, null);
@@ -120,7 +119,6 @@ public void ComprehensiveCheck()
             this.CheckPublicSuffix("www.test.k12.ak.us", "test.k12.ak.us");
         }
 
-        [DataTestMethod]
         [DataRow("COM")]
         [DataRow("com")]
         [DataRow("公司.cn")]
@@ -150,6 +148,7 @@ public void ComprehensiveCheck()
         [DataRow("ec2-34-206-8-177.compute-1.amazonaws.com")]
         [DataRow("s3-website.us-east-2.amazonaws.com")]
         [DataRow("test.stg.dev")]
+        [TestMethod]
         public void TldCheck(string domain)
         {
             this.CheckPublicSuffix(domain, null);

src/Nager.PublicSuffix.UnitTest/RuleProviderTest.cs

@@ -37,7 +37,7 @@ public async Task FileTldRuleProviderTest()
 
             var domainDataStructure = localFileRuleProvider.GetDomainDataStructure();
 
-            Assert.AreEqual(1460, domainDataStructure.Nested.Count);
+            Assert.HasCount(1460, domainDataStructure.Nested);
         }
     }
 }

src/Nager.PublicSuffix.UnitTest/TldRuleTest.cs

@@ -8,45 +8,45 @@ namespace Nager.PublicSuffix.UnitTest
     public class TldRuleTest
     {
         [TestMethod]
-        [ExpectedException(typeof(ArgumentException), "RuleData is empty")]
         public void InvalidRuleTest1()
         {
-            new TldRule("");
+            var ex = Assert.ThrowsExactly<ArgumentException>(() => new TldRule(""));
+            Assert.AreEqual("RuleData is empty", ex.Message);
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentException), "RuleData is empty")]
         public void InvalidRuleTest2()
         {
-            new TldRule(null);
+            var ex = Assert.ThrowsExactly<ArgumentException>(() => new TldRule(null));
+            Assert.AreEqual("RuleData is empty", ex.Message);
         }
 
         [TestMethod]
-        [ExpectedException(typeof(FormatException), "Wildcard syntax not correct")]
         public void InvalidRuleTest3()
         {
-            new TldRule("*com");
+            var ex = Assert.ThrowsExactly<FormatException>(() => new TldRule("*com"));
+            Assert.AreEqual("Wildcard syntax not correct", ex.Message);
         }
 
         [TestMethod]
-        [ExpectedException(typeof(FormatException), "Wildcard syntax not correct")]
         public void InvalidRuleTest4()
         {
-            new TldRule("*bar.foo");
+            var ex = Assert.ThrowsExactly<FormatException>(() => new TldRule("*bar.foo"));
+            Assert.AreEqual("Wildcard syntax not correct", ex.Message);
         }
 
         [TestMethod]
-        [ExpectedException(typeof(FormatException), "Rule contains invalid empty part")]
         public void InvalidRuleTest5()
         {
-            new TldRule(".com");
+            var ex = Assert.ThrowsExactly<FormatException>(() => new TldRule(".com"));
+            Assert.AreEqual("Rule contains empty part", ex.Message);
         }
 
         [TestMethod]
-        [ExpectedException(typeof(FormatException), "Rule contains invalid empty part")]
         public void InvalidRuleTest6()
         {
-            new TldRule("www..com");
+            var ex = Assert.ThrowsExactly<FormatException>(() => new TldRule("www..com"));
+            Assert.AreEqual("Rule contains empty part", ex.Message);
         }
 
         [TestMethod]