Modifications to TestPackage API

Directory.Packages.props

@@ -11,7 +11,7 @@
 		<PackageVersion Include="Nullable" Version="1.3.1" />
 		<PackageVersion Include="NUnit" Version="4.6.1" />
 		<PackageVersion Include="NUnitLite" Version="4.6.1" />
-		<PackageVersion Include="NUnit.Extensibility.Api" Version="4.0.0-beta.4.8" />
+		<PackageVersion Include="NUnit.Extensibility.Api" Version="4.0.0-beta.5" />
 		<PackageVersion Include="StyleCop.Analyzers.Unstable" Version="1.2.0.556" />
 		<PackageVersion Include="TunnelVisionLabs.ReferenceAssemblyAnnotator" Version="1.0.0-alpha.160" />
 	</ItemGroup>

build.cake

@@ -1,5 +1,5 @@
 // Load the recipe
-#load nuget:?package=NUnit.Cake.Recipe&version=2.0.0-beta.4.11
+#load nuget:?package=NUnit.Cake.Recipe&version=2.0.0-beta.5
 // Comment out above line and uncomment below for local tests of recipe changes
 //#load ../NUnit.Cake.Recipe/recipe/*.cake
 

src/NUnit.Engine.Api.Tests/TestPackageTests.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Charlie Poole, Rob Prouse and Contributors. MIT License - see LICENSE.txt
 
 using System.IO;
+using System.Security.Cryptography.X509Certificates;
+using NUnit.Common;
 using NUnit.Framework;
 
 namespace NUnit.Engine.Api
@@ -15,6 +17,11 @@ public class TestPackageTests
         public TestPackageTests(string fileNames)
         {
             _fileNames = fileNames.Split(',');
+        }
+
+        [SetUp]
+        public void CreatePackage()
+        {
             _package = new TestPackage(_fileNames);
         }
 
@@ -46,11 +53,200 @@ public void HasSubPackageForEachFile()
             }
         }
 
-        //[Test]
+        [Test]
         public void SubPackagesHaveNoSubPackages()
         {
             foreach (TestPackage subPackage in _package.SubPackages)
                 Assert.That(subPackage.SubPackages.Count, Is.EqualTo(0));
         }
+
+        [Test]
+        public void SubPackagesHaveNoSettingsInitially()
+        {
+            foreach (TestPackage subPackage in _package.SubPackages)
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(0));
+        }
+
+        private static readonly PackageSetting MAX_AGENTS_42 = SettingDefinitions.MaxAgents.WithValue(42);
+        private static readonly PackageSetting MAX_AGENTS_99 = SettingDefinitions.MaxAgents.WithValue(99);
+
+        [Test]
+        public void AddStandardSettingToPackage([Values(false, true)] bool recursive)
+        {
+            _package.AddSetting(MAX_AGENTS_99, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting(MAX_AGENTS_99.Name), Is.EqualTo(99));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting(MAX_AGENTS_99.Name), Is.EqualTo(99));
+            }
+        }
+
+        [TestCase("setting1", "value1", false)]
+        [TestCase("setting1", "value1", true)]
+        public void AddCustomStringSettingToPackage(string settingName, string settingValue, bool recursive)
+        {
+            _package.AddSetting(settingName, settingValue, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting(settingName), Is.EqualTo(settingValue));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting(settingName), Is.EqualTo(settingValue));
+            }
+        }
+
+        [Test]
+        public void AddCustomBooleanSettingToPackage([Values(false, true)] bool recursive)
+        {
+            _package.AddSetting("setting1", true, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting("setting1"), Is.EqualTo(true));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting("setting1"), Is.EqualTo(true));
+            }
+        }
+
+        [Test]
+        public void AddCustomIntSettingToPackage([Values(false, true)] bool recursive)
+        {
+            _package.AddSetting("setting1", 42, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting("setting1"), Is.EqualTo(42));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting("setting1"), Is.EqualTo(42));
+            }
+        }
+
+        [Test]
+        public void ApplyStandardSettingToPackage([Values(false, true)] bool recursive)
+        {
+            _package.ApplySetting(MAX_AGENTS_99, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting(MAX_AGENTS_99.Name), Is.EqualTo(99));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting(MAX_AGENTS_99.Name), Is.EqualTo(99));
+            }
+
+            _package.ApplySetting(MAX_AGENTS_42, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting(MAX_AGENTS_42.Name), Is.EqualTo(42));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting(MAX_AGENTS_42.Name), Is.EqualTo(42));
+            }
+        }
+
+        [Test]
+        public void ApplyCustomStringSettingToPackage([Values(false, true)] bool recursive)
+        {
+            _package.ApplySetting("setting1", "value1", recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting("setting1"), Is.EqualTo("value1"));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting("setting1"), Is.EqualTo("value1"));
+            }
+
+            _package.ApplySetting("setting1", "value2", recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting("setting1"), Is.EqualTo("value2"));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting("setting1"), Is.EqualTo("value2"));
+            }
+        }
+
+        [Test]
+        public void ApplyCustomBooleanSettingToPackage([Values(false, true)] bool recursive)
+        {
+            _package.ApplySetting("setting1", true, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting("setting1"), Is.EqualTo(true));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting("setting1"), Is.EqualTo(true));
+            }
+
+            _package.ApplySetting("setting1", false, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting("setting1"), Is.EqualTo(false));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting("setting1"), Is.EqualTo(false));
+            }
+        }
+
+        [Test]
+        public void ApplyCustomIntSettingToPackage([Values(false, true)] bool recursive)
+        {
+            _package.ApplySetting("setting1", 99, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting("setting1"), Is.EqualTo(99));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting("setting1"), Is.EqualTo(99));
+            }
+
+            _package.ApplySetting("setting1", 42, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            Assert.That(_package.Settings.GetSetting("setting1"), Is.EqualTo(42));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(recursive ? 1 : 0));
+                if (recursive)
+                    Assert.That(subPackage.Settings.GetSetting("setting1"), Is.EqualTo(42));
+            }
+        }
+
+        [Test]
+        public void RemoveStandardSettingFromPackage([Values(false, true)] bool recursive)
+        {
+            _package.AddSetting(MAX_AGENTS_99, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            _package.RemoveSetting(MAX_AGENTS_99.Name, recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(0));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(0));
+            }
+        }
+
+        [Test]
+        public void RemoveCustomSettingFromPackage([Values(false, true)] bool recursive)
+        {
+            _package.AddSetting("setting1", "value1", recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(1));
+            _package.RemoveSetting("setting1", recursive);
+            Assert.That(_package.Settings.Count, Is.EqualTo(0));
+            foreach (TestPackage subPackage in _package.SubPackages)
+            {
+                Assert.That(subPackage.Settings.Count, Is.EqualTo(0));
+            }
+        }
     }
 }

src/NUnit.Engine.Api/NUnit.Engine.Api.csproj

@@ -1,19 +1,23 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <RootNamespace>NUnit.Engine</RootNamespace>
-    <TargetFrameworks>net462;netstandard2.0</TargetFrameworks>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
-  </PropertyGroup>
+    <PropertyGroup>
+        <RootNamespace>NUnit.Engine</RootNamespace>
+        <TargetFrameworks>net462;netstandard2.0</TargetFrameworks>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    </PropertyGroup>
 
-  <PropertyGroup>
-    <PackageId>NUnit.Engine.Api</PackageId>
-    <AssemblyTitle>NUnit Engine API ($(TargetFramework))</AssemblyTitle>
-    <Description>Defines the interfaces used by runners and engine extensions to access the NUnit Engine. Not normally needed by direct users who simply want to run tests.</Description>
-  </PropertyGroup>
+	<ItemGroup>
+		<InternalsVisibleTo Include="NUnit.Engine.API.Tests, PublicKey=$(NUnitPublicKey)" />
+	</ItemGroup>
+
+    <PropertyGroup>
+        <PackageId>NUnit.Engine.Api</PackageId>
+        <AssemblyTitle>NUnit Engine API ($(TargetFramework))</AssemblyTitle>
+        <Description>Defines the interfaces used by runners and engine extensions to access the NUnit Engine. Not normally needed by direct users who simply want to run tests.</Description>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="NUnit.Extensibility.Api" />
-  </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="NUnit.Extensibility.Api" />
+    </ItemGroup>
 
 </Project>

src/NUnit.Engine.Api/PackageSettings.cs

@@ -65,15 +65,15 @@ public T GetValueOrDefault<T>(SettingDefinition<T> definition)
         /// Adds a setting to the list directly.
         /// </summary>
         /// <param name="setting">A PackageSetting instance</param>
-        public void Add(PackageSetting setting) => _settings.Add(setting.Name, setting);
+        internal void Add(PackageSetting setting) => _settings.Add(setting.Name, setting);
 
         /// <summary>
         /// Creates and adds a setting to the list, specified by the name and a string value.
         /// The string value is converted to a typed PackageSetting if the name specifies a known SettingDefinition.
         /// </summary>
         /// <param name="name">The name of the setting.</param>
         /// <param name="value">The corresponding value to set.</param>
-        public void Add(string name, string value)
+        internal void Add(string name, string value)
         {
             var definition = SettingDefinitions.Lookup(name);
 
@@ -90,7 +90,7 @@ public void Add(string name, string value)
         /// </summary>
         /// <param name="name">The name of the setting.</param>
         /// <param name="value">The corresponding value to set.</param>
-        public void Add(string name, bool value)
+        internal void Add(string name, bool value)
         {
             var definition = SettingDefinitions.Lookup(name);
 
@@ -106,7 +106,7 @@ public void Add(string name, bool value)
         /// </summary>
         /// <param name="name">The name of the setting.</param>
         /// <param name="value">The corresponding value to set.</param>
-        public void Add(string name, int value)
+        internal void Add(string name, int value)
         {
             var definition = SettingDefinitions.Lookup(name);
 
@@ -120,14 +120,14 @@ public void Add(string name, int value)
         /// <summary>
         /// Adds or replaces a setting to the list.
         /// </summary>
-        public void Set(PackageSetting setting) => _settings[setting.Name] = setting;
+        internal void Set(PackageSetting setting) => _settings[setting.Name] = setting;
 
         /// <summary>
         /// Adds or replaces a setting to the list.
         /// </summary>
         /// <param name="name">The name of the setting.</param>
         /// <param name="value">The corresponding value to set.</param>
-        public void Set<T>(string name, T value)
+        internal void Set<T>(string name, T value)
             where T : notnull
         {
             Set(new PackageSetting<T>(name, value));
@@ -137,7 +137,7 @@ public void Set<T>(string name, T value)
         /// Remove a setting
         /// </summary>
         /// <param name="setting">The setting to remove</param>
-        public void Remove(SettingDefinition setting)
+        internal void Remove(SettingDefinition setting)
         {
             _settings.Remove(setting.Name);
         }
@@ -146,7 +146,7 @@ public void Remove(SettingDefinition setting)
         /// Remove a setting
         /// </summary>
         /// <param name="settingName">The name of the setting to remove</param>
-        public void Remove(string settingName)
+        internal void Remove(string settingName)
         {
             _settings.Remove(settingName);
         }