Allow non-existent paths to be removed

Also allows non-existent paths to be added to the source list using -Force. Resolves issue #21.

Author: heaths

src/PowerShell/Help.xml

@@ -1281,6 +1281,9 @@
     <parameter name="LiteralPath">
       The directory or URL to register. The value of -LiteralPath is used exactly as typed. No characters are interpreted as wildcards.
     </parameter>
+    <parameter name="Force">
+      Whether to validate that directories exist before they are added to the source list.
+    </parameter>
     <parameter name="PassThru">
       Whether to return the remaining registered source through the pipeline.
     </parameter>

src/PowerShell/Microsoft.Tools.WindowsInstaller.PowerShell.dll-Help.xml

@@ -33,6 +33,23 @@ namespace Microsoft.Tools.WindowsInstaller.PowerShell.Commands
     public sealed class AddSourceCommand : SourcePathCommandBase
     {
         private static readonly string ErrorId = "DirectoryNotFound";
+        private bool shouldExist = true;
+
+        /// <summary>
+        /// Gets or sets whether to validate that directories exist before they are added to the source list.
+        /// </summary>
+        [Parameter]
+        public SwitchParameter Force
+        {
+            get { return !this.shouldExist; }
+            set { this.shouldExist = !value; }
+        }
+
+        protected override bool ShouldExist
+        {
+            get { return this.shouldExist; }
+            set { this.shouldExist = value; }
+        }
 
         /// <summary>
         /// Registers a source path to a product or patch.
@@ -46,7 +63,7 @@ protected override void EndProcessing()
                 {
                     foreach (var path in param.Paths)
                     {
-                        if (this.Validate(path))
+                        if (this.Force || this.Validate(path))
                         {
                             installation.SourceList.Add(path);
                         }

src/PowerShell/PowerShell/Commands/AddSourceCommand.cs

@@ -20,6 +20,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
+using System.Collections.Generic;
 using System.Management.Automation;
 
 namespace Microsoft.Tools.WindowsInstaller.PowerShell.Commands
@@ -53,20 +54,33 @@ public string[] LiteralPath
         [Parameter]
         public SwitchParameter PassThru { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the <see cref="Path"/> or <see cref="LiteralPath"/> must exist.
+        /// </summary>
+        protected virtual bool ShouldExist { get; set; }
+
         /// <summary>
         /// Adds the resolved path to the <see cref="SourceCommandBase.Parameters"/>.
         /// </summary>
         /// <param name="param">The <see cref="SourceCommandBase.Parameters"/> to update.</param>
         protected override void UpdateParameters(Parameters param)
         {
-            var items = this.InvokeProvider.Item.Get(this.Path, true, ParameterSet.LiteralPath == this.ParameterSetName);
-
-            foreach (var item in items)
+            IEnumerable<string> paths;
+            if (this.ShouldExist)
             {
-                var path = item.GetPropertyValue<string>("PSPath");
-                path = this.SessionState.Path.GetUnresolvedProviderPathFromPSPath(path);
+                paths = this.InvokeProvider.Item
+                    .Get(this.Path, true, ParameterSet.LiteralPath == this.ParameterSetName)
+                    .Select(item => item.GetPropertyValue<string>("PSPath"));
+            }
+            else
+            {
+                paths = this.Path;
+            }
 
-                param.Paths.Add(path);
+            foreach (var path in paths)
+            {
+                var providerPath = this.SessionState.Path.GetUnresolvedProviderPathFromPSPath(path);
+                param.Paths.Add(providerPath);
             }
         }
     }

src/PowerShell/PowerShell/Commands/SourcePathCommandBase.cs

@@ -24,6 +24,8 @@
 using System.Management.Automation;
 using Microsoft.Deployment.WindowsInstaller;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
 
 namespace Microsoft.Tools.WindowsInstaller.PowerShell.Commands
 {
@@ -41,35 +43,15 @@ public class SourceCommandTests : TestBase
         [TestMethod]
         public void ModifyProductSource()
         {
-            PSObject obj = null;
-
-            // First attempt to see if there are any unmanaged products installed.
-            using (var p = CreatePipeline("get-msiproductinfo -context userunmanaged"))
-            {
-                var output = p.Invoke();
-                if (null != output && 0 < output.Count())
-                {
-                    obj = output[0];
-                }
-                else
-                {
-                    Assert.Inconclusive("There are no unmanaged products installed with which to test source list modifications.");
-                }
-            }
-
-            // Retain the original source locations so we can attempt to restore it.
-            var product = obj.As<ProductInstallation>();
-            var original = product.SourceList.ToArray();
-
-            try
+            this.TestProductSources((obj, product, original) =>
             {
                 using (var p = CreatePipeline(string.Format(@"$Input | add-msisource -path '{0}' -passthru", this.TestContext.DeploymentDirectory)))
                 {
                     p.Input.Write(obj);
                     var output = p.Invoke();
 
                     Assert.IsNotNull(output);
-                    Assert.AreEqual<int>(original.Length + 1, output.Count());
+                    Assert.AreEqual(original.Count + 1, output.Count());
                 }
 
                 using (var p = CreatePipeline(@"$Input | add-msisource -path 'ShouldNotExist.txt' -passthru"))
@@ -89,8 +71,8 @@ public void ModifyProductSource()
 
                     // Should return the previous number of source locations we already registered.
                     Assert.IsNotNull(output);
-                    Assert.AreEqual<int>(original.Length + 1, output.Count());
-                    Assert.AreEqual<int>(1, p.Error.Count);
+                    Assert.AreEqual(original.Count + 1, output.Count());
+                    Assert.AreEqual(1, p.Error.Count);
                 }
 
                 using (var p = CreatePipeline(@"$Input | clear-msisource; $Input | get-msisource"))
@@ -101,17 +83,17 @@ public void ModifyProductSource()
                     Assert.IsTrue(null == output || 0 == output.Count());
                 }
 
-                var paths = new string[original.Length + 1];
+                var paths = new string[original.Count + 1];
                 paths[0] = this.TestContext.DeploymentDirectory;
                 original.CopyTo(paths, 1);
 
-                using (var p = CreatePipeline(string.Format(@"$Input | add-msisource '{0}' -passthru", product.ProductCode)))
+                using (var p = CreatePipeline(string.Format(@"$Input | add-msisource '{0}' -force -passthru", product.ProductCode)))
                 {
                     p.Input.Write(paths, true);
                     var output = p.Invoke();
 
                     Assert.IsNotNull(output);
-                    Assert.AreEqual<int>(paths.Length, output.Count());
+                    Assert.AreEqual(paths.Length, output.Count());
                 }
 
                 using (var p = CreatePipeline(string.Format(@"$Input | remove-msisource -path '{0}' -passthru", this.TestContext.DeploymentDirectory)))
@@ -120,8 +102,110 @@ public void ModifyProductSource()
                     var output = p.Invoke();
 
                     Assert.IsNotNull(output);
-                    Assert.AreEqual<int>(original.Length, output.Count());
+                    Assert.AreEqual(original.Count, output.Count());
+                }
+            });
+        }
+
+        [TestMethod]
+        public void AddSourceTestsPath()
+        {
+            this.TestProductSources((obj, product, original) =>
+            {
+                using (var p = CreatePipeline(@"$Input | add-msisource -path 'C:\ShouldNotExist\AddSourceTestsPath' -passthru"))
+                {
+                    p.Input.Write(obj);
+
+                    try
+                    {
+                        p.Invoke();
+                        Assert.Fail("Expected CmdletInvocationException exception");
+                    }
+                    catch (CmdletInvocationException)
+                    {
+                        return;
+                    }
+                    catch (Exception ex)
+                    {
+                        Assert.Fail("Expected CmdletInvocationException exception; caught {0} exception", ex.GetType().Name);
+                    }
+                }
+            });
+        }
+
+        [TestMethod]
+        public void AddSourceForceNoTestsPath()
+        {
+            this.TestProductSources((obj, product, original) =>
+            {
+                using (var p = CreatePipeline(@"$Input | add-msisource -path 'C:\ShouldNotExist\AddSourceForceNoTestsPath' -force -passthru"))
+                {
+                    p.Input.Write(obj);
+                    var output = p.Invoke();
+
+                    Assert.IsFalse(p.HadErrors);
+                    Assert.IsNotNull(output);
+                    Assert.AreEqual(original.Count + 1, output.Count());
                 }
+            });
+        }
+
+        [TestMethod]
+        public void RemoveSourceNoTestsPath()
+        {
+            this.TestProductSources((obj, product, original) =>
+            {
+                using (var p = CreatePipeline(@"$Input | remove-msisource -path 'C:\ShouldNotExist\RemoveSourceNoTestsPath' -passthru"))
+                {
+                    p.Input.Write(obj);
+                    var output = p.Invoke();
+
+                    Assert.IsFalse(p.HadErrors);
+                    Assert.IsNotNull(output);
+                    Assert.AreEqual(original.Count, output.Count());
+                }
+            });
+        }
+
+        private PSObject FindTestProduct()
+        {
+            using (var p = CreatePipeline("get-msiproductinfo -context userunmanaged"))
+            {
+                var output = p.Invoke();
+                if (null != output && 0 < output.Count())
+                {
+                    return output[0];
+                }
+            }
+
+            return null;
+        }
+
+        private void TestProductSources(Action<PSObject, ProductInstallation, ICollection<string>> action)
+        {
+            PSObject obj = null;
+
+            // First attempt to see if there are any unmanaged products installed.
+            using (var p = CreatePipeline("get-msiproductinfo -context userunmanaged"))
+            {
+                var output = p.Invoke();
+                if (null != output && 0 < output.Count())
+                {
+                    obj = output[0];
+                }
+                else
+                {
+                    Assert.Inconclusive("There are no unmanaged products installed with which to test source list modifications.");
+                }
+            }
+
+            // Retain the original source locations so we can attempt to restore it.
+            var product = obj.As<ProductInstallation>();
+            var original = product.SourceList.ToArray();
+
+            try
+            {
+                action(obj, product, original);
             }
             finally
             {

test/PowerShell.Test/PowerShell/Commands/SourceCommandTests.cs

@@ -73,7 +73,7 @@ internal RegistryXml(RegistryKey key)
         }
 
         /// <summary>
-        /// Gets the propety dictionary.
+        /// Gets the property dictionary.
         /// </summary>
         internal Dictionary<string, string> Properties { get; private set; }
 
@@ -82,10 +82,10 @@ internal RegistryXml(RegistryKey key)
         /// </summary>
         /// <param name="reader">The <see cref="XmlReader"/> that contains the keys and values to import.</param>
         /// <exception cref="NotSupportedException">A hive name was specified that is not supported, or a value type was not supported.</exception>
-        /// <exception cref="XmlException">A general XML exception occured.</exception>
+        /// <exception cref="XmlException">A general XML exception occurred.</exception>
         internal void Import(XmlReader reader)
         {
-            Debug.Assert(null != reader, $@"The argument ""{nameof(reader)}"" is null.");
+            Debug.Assert(null != reader, @"The argument ""reader"" is null.");
 
             while (reader.Read())
             {