Refactor tests using Theory

test/DotNetEnv.Tests/ExtensionsTests.cs

@@ -1,42 +1,62 @@
 using System;
 using System.Collections.Generic;
 using DotNetEnv.Extensions;
+using DotNetEnv.Tests.XUnit;
 using Xunit;
 
 namespace DotNetEnv.Tests;
 
 public class ExtensionsTests
 {
-    [Fact]
-    public void ToDotEnvDictionaryTest()
+    private static readonly KeyValuePair<string, string> FirstValuePair = new("key", "value");
+    private static readonly KeyValuePair<string, string> FirstValuePairDupe = new("key", "dupe");
+    private static readonly KeyValuePair<string, string> SecondValuePair = new("key2", "value2");
+
+    private static readonly KeyValuePair<string, string>[] KvpSetNoDupe = { FirstValuePair, SecondValuePair };
+    private static readonly KeyValuePair<string, string>[] KvpSetWithDupe = { FirstValuePair, FirstValuePairDupe };
+
+    /// <summary>
+    /// Data: _, dictionaryOption, input, expectedValue
+    /// </summary>
+    public static readonly TheoryData<
+            string, CreateDictionaryOption, KeyValuePair<string, string>[], KeyValuePair<string, string>[]>
+        ToDotEnvDictionaryTestData =
+            new IndexedTheoryData<
+                CreateDictionaryOption, KeyValuePair<string, string>[], KeyValuePair<string, string>[]>
+            {
+                { CreateDictionaryOption.Throw, KvpSetNoDupe, KvpSetNoDupe },
+                { CreateDictionaryOption.TakeFirst, KvpSetWithDupe, new[] { FirstValuePair } },
+                { CreateDictionaryOption.TakeFirst, KvpSetNoDupe, KvpSetNoDupe },
+                { CreateDictionaryOption.TakeLast, KvpSetWithDupe, new[] { FirstValuePairDupe } },
+                { CreateDictionaryOption.TakeLast, KvpSetNoDupe, KvpSetNoDupe },
+            };
+
+    [Theory]
+    [MemberData(nameof(ToDotEnvDictionaryTestData))]
+    public void ToDotEnvDictionaryWithKvpSetNoDupeShouldContainValues(string _,
+        CreateDictionaryOption dictionaryOption,
+        KeyValuePair<string, string>[] input,
+        KeyValuePair<string, string>[] expected)
     {
-        var kvpSetNoDupe = new List<KeyValuePair<string, string>>()
-        {
-            new("key", "value"),
-            new("key2", "value2"),
-        };
-
-        var kvpSetWithDupe = new List<KeyValuePair<string, string>>()
-        {
-            new("key", "value"),
-            new("key", "value2"),
-        };
-
-        Assert.Throws<ArgumentException>(() => kvpSetWithDupe.ToDotEnvDictionary(CreateDictionaryOption.Throw));
-        var noDupeAndThrowOption = kvpSetNoDupe.ToDotEnvDictionary(CreateDictionaryOption.Throw);
-        Assert.Equal("value", noDupeAndThrowOption["key"]);
-        Assert.Equal("value2", noDupeAndThrowOption["key2"]);
-
-        var withDupeAndTakeFirstOption = kvpSetWithDupe.ToDotEnvDictionary(CreateDictionaryOption.TakeFirst);
-        Assert.Equal("value", withDupeAndTakeFirstOption["key"]);
-        var noDupeAndTakeFirstOption = kvpSetNoDupe.ToDotEnvDictionary(CreateDictionaryOption.TakeFirst);
-        Assert.Equal("value", noDupeAndTakeFirstOption["key"]);
-        Assert.Equal("value2", noDupeAndTakeFirstOption["key2"]);
-
-        var withDupeAndTakeLastOption = kvpSetWithDupe.ToDotEnvDictionary();
-        Assert.Equal("value2", withDupeAndTakeLastOption["key"]);
-        var noDupeAndTakeLastOption = kvpSetNoDupe.ToDotEnvDictionary();
-        Assert.Equal("value", noDupeAndTakeLastOption["key"]);
-        Assert.Equal("value2", noDupeAndTakeLastOption["key2"]);
+        var dotEnvDictionary = input.ToDotEnvDictionary(dictionaryOption);
+
+        foreach (var (key, value) in expected)
+            Assert.Equal(value, dotEnvDictionary[key]);
     }
+
+    [Theory]
+    [MemberData(nameof(ToDotEnvDictionaryTestData))]
+    public void ToDotEnvDictionaryWithKvpSetNoDupeShouldHaveCorrectNumberOfEntries(string _,
+        CreateDictionaryOption dictionaryOption,
+        KeyValuePair<string, string>[] input,
+        KeyValuePair<string, string>[] expectedValues)
+    {
+        var dotEnvDictionary = input.ToDotEnvDictionary(dictionaryOption);
+
+        Assert.Equal(expectedValues.Length, dotEnvDictionary.Count);
+    }
+
+    [Fact]
+    public void ToDotEnvDictionaryWithThrowOptionShouldThrowOnDupes() =>
+        Assert.Throws<ArgumentException>(() => KvpSetWithDupe.ToDotEnvDictionary(CreateDictionaryOption.Throw));
 }

test/DotNetEnv.Tests/FrameworkTests.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Text;
+using DotNetEnv.Tests.Helper;
+using Xunit;
+
+namespace DotNetEnv.Tests;
+
+public class FrameworkTests
+{
+    [Fact]
+    public void CheckUnicodeFunctionality()
+    {
+        Assert.Equal("®", Encoding.Unicode.GetString(new byte[] { 0xae, 0x00 }));
+        Assert.Equal(UnicodeChars.Rocket, Encoding.UTF32.GetString(new byte[] { 0x80, 0xf6, 0x01, 0x00 }));
+        Assert.Equal(UnicodeChars.Rocket, Encoding.UTF32.GetString(new byte[] { 0x80, 0xf6, 0x1, 0x0 }));
+    }
+
+    [Fact]
+    public void CheckEnvironmentVariableFunctionality()
+    {
+        Environment.SetEnvironmentVariable("EV_DNE", null);
+        Assert.Null(Environment.GetEnvironmentVariable("EV_DNE"));
+
+        // Note that dotnet returns null if the env var is empty -- even if it was set to empty!
+        Environment.SetEnvironmentVariable("EV_DNE", "");
+        Assert.Null(Environment.GetEnvironmentVariable("EV_DNE"));
+    }
+}

test/DotNetEnv.Tests/Helper/UnicodeChars.cs

@@ -0,0 +1,10 @@
+namespace DotNetEnv.Tests.Helper;
+
+public struct UnicodeChars
+{
+    // https://stackoverflow.com/questions/602912/how-do-you-echo-a-4-digit-unicode-character-in-bash
+    // printf '\xE2\x98\xA0'
+    // printf ☠ | hexdump  # hexdump has bytes flipped per word (2 bytes, 4 hex)
+
+    public const string Rocket = "\ud83d\ude80"; // 🚀
+}

test/DotNetEnv.Tests/LoadOptionsTests.cs

@@ -1,101 +1,41 @@
+using System;
+using DotNetEnv.Tests.XUnit;
 using Xunit;
 
 namespace DotNetEnv.Tests
 {
     public class LoadOptionsTests
     {
-        [Fact]
-        public void StaticEnvTest()
+        /// <summary>
+        /// Data: _, optionsUnderTest, expectedSetEnvVars, expectedClobberExistingVars, expectedOnlyExactPath
+        /// </summary>
+        public static readonly TheoryData<string, LoadOptions, bool , bool, bool>
+            LoadOptionTestCombinations = new IndexedTheoryData<LoadOptions, bool, bool, bool>()
+            {
+                { Env.NoEnvVars(), false, true, true },
+                { Env.NoClobber(), true, false, true },
+                { Env.TraversePath(), true, true, false },
+                { LoadOptions.NoEnvVars(), false, true, true },
+                { LoadOptions.NoClobber(), true, false, true },
+                { LoadOptions.TraversePath(), true, true, false },
+                { new LoadOptions(), true, true, true },
+                { new LoadOptions().NoEnvVars(), false, true, true },
+                { new LoadOptions().NoClobber(), true, false, true },
+                { new LoadOptions().TraversePath(), true, true, false },
+                { Env.NoEnvVars().NoClobber().TraversePath(), false, false, false },
+                { Env.NoClobber().TraversePath(), true, false, false },
+                { Env.NoEnvVars().NoClobber(), false, false, true },
+                { Env.NoEnvVars().TraversePath(), false, true, false },
+            };
+
+        [Theory]
+        [MemberData(nameof(LoadOptionTestCombinations))]
+        public void LoadOptionsShouldHaveCorrectPropertiesSet(string _, LoadOptions optionsUnderTest,
+            bool expectedSetEnvVars, bool expectedClobberExistingVars, bool expectedOnlyExactPath)
         {
-            LoadOptions options;
-
-            options = DotNetEnv.Env.NoEnvVars();
-            Assert.False(options.SetEnvVars);
-            Assert.True(options.ClobberExistingVars);
-            Assert.True(options.OnlyExactPath);
-
-            options = DotNetEnv.Env.NoClobber();
-            Assert.True(options.SetEnvVars);
-            Assert.False(options.ClobberExistingVars);
-            Assert.True(options.OnlyExactPath);
-
-            options = DotNetEnv.Env.TraversePath();
-            Assert.True(options.SetEnvVars);
-            Assert.True(options.ClobberExistingVars);
-            Assert.False(options.OnlyExactPath);
-        }
-
-        [Fact]
-        public void StaticOptionsTest()
-        {
-            LoadOptions options;
-
-            options = DotNetEnv.LoadOptions.NoEnvVars();
-            Assert.False(options.SetEnvVars);
-            Assert.True(options.ClobberExistingVars);
-            Assert.True(options.OnlyExactPath);
-
-            options = DotNetEnv.LoadOptions.NoClobber();
-            Assert.True(options.SetEnvVars);
-            Assert.False(options.ClobberExistingVars);
-            Assert.True(options.OnlyExactPath);
-
-            options = DotNetEnv.LoadOptions.TraversePath();
-            Assert.True(options.SetEnvVars);
-            Assert.True(options.ClobberExistingVars);
-            Assert.False(options.OnlyExactPath);
-        }
-
-        [Fact]
-        public void InstanceTest()
-        {
-            LoadOptions options;
-
-            options = new DotNetEnv.LoadOptions();
-            Assert.True(options.SetEnvVars);
-            Assert.True(options.ClobberExistingVars);
-            Assert.True(options.OnlyExactPath);
-
-            options = new DotNetEnv.LoadOptions().NoEnvVars();
-            Assert.False(options.SetEnvVars);
-            Assert.True(options.ClobberExistingVars);
-            Assert.True(options.OnlyExactPath);
-
-            options = new DotNetEnv.LoadOptions().NoClobber();
-            Assert.True(options.SetEnvVars);
-            Assert.False(options.ClobberExistingVars);
-            Assert.True(options.OnlyExactPath);
-
-            options = new DotNetEnv.LoadOptions().TraversePath();
-            Assert.True(options.SetEnvVars);
-            Assert.True(options.ClobberExistingVars);
-            Assert.False(options.OnlyExactPath);
-        }
-
-        [Fact]
-        public void ComboTest()
-        {
-            LoadOptions options;
-
-            options = DotNetEnv.Env.NoEnvVars().NoClobber().TraversePath();
-            Assert.False(options.SetEnvVars);
-            Assert.False(options.ClobberExistingVars);
-            Assert.False(options.OnlyExactPath);
-
-            options = DotNetEnv.Env.NoClobber().TraversePath();
-            Assert.True(options.SetEnvVars);
-            Assert.False(options.ClobberExistingVars);
-            Assert.False(options.OnlyExactPath);
-
-            options = DotNetEnv.Env.NoEnvVars().NoClobber();
-            Assert.False(options.SetEnvVars);
-            Assert.False(options.ClobberExistingVars);
-            Assert.True(options.OnlyExactPath);
-
-            options = DotNetEnv.Env.NoEnvVars().TraversePath();
-            Assert.False(options.SetEnvVars);
-            Assert.True(options.ClobberExistingVars);
-            Assert.False(options.OnlyExactPath);
+            Assert.Equal(expectedSetEnvVars, optionsUnderTest.SetEnvVars);
+            Assert.Equal(expectedClobberExistingVars, optionsUnderTest.ClobberExistingVars);
+            Assert.Equal(expectedOnlyExactPath, optionsUnderTest.OnlyExactPath);
         }
     }
 }