Add tests for directory names with wildcards.

1 files changed, 124 insertions, 0 deletions

diff --git a/Duplicati/UnitTest/ProblematicPathTests.cs b/Duplicati/UnitTest/ProblematicPathTests.cs
index 7d1f05a3a..4009748f4 100644
--- a/Duplicati/UnitTest/ProblematicPathTests.cs
+++ b/Duplicati/UnitTest/ProblematicPathTests.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using Duplicati.Library.Common;
 using Duplicati.Library.Common.IO;
 using Duplicati.Library.Interface;
 using Duplicati.Library.Main;
@@ -23,6 +24,129 @@ namespace Duplicati.UnitTest
 
         [Test]
         [Category("ProblematicPath")]
+        public void DirectoriesWithWildcards()
+        {
+            if (Platform.IsClientWindows)
+            {
+                return;
+            }
+
+            const string file = "file";
+            List<string> directories = new List<string>();
+
+            const string asterisk = "*";
+            string dirWithAsterisk = Path.Combine(this.DATAFOLDER, asterisk);
+            SystemIO.IO_OS.DirectoryCreate(dirWithAsterisk);
+            WriteFile(SystemIO.IO_OS.PathCombine(dirWithAsterisk, file), new byte[] {0});
+            directories.Add(dirWithAsterisk);
+
+            const string questionMark = "?";
+            string dirWithQuestionMark = Path.Combine(this.DATAFOLDER, questionMark);
+            SystemIO.IO_OS.DirectoryCreate(dirWithQuestionMark);
+            WriteFile(SystemIO.IO_OS.PathCombine(dirWithQuestionMark, file), new byte[] {1});
+            directories.Add(dirWithQuestionMark);
+
+            const string dir = "dir";
+            string normalDir = Path.Combine(this.DATAFOLDER, dir);
+            SystemIO.IO_OS.DirectoryCreate(normalDir);
+            WriteFile(SystemIO.IO_OS.PathCombine(normalDir, file), new byte[] {2});
+            directories.Add(normalDir);
+
+            // Backup all files.
+            Dictionary<string, string> options = new Dictionary<string, string>(this.TestOptions);
+            using (Controller c = new Controller("file://" + this.TARGETFOLDER, options, null))
+            {
+                IBackupResults backupResults = c.Backup(new[] {this.DATAFOLDER});
+                Assert.AreEqual(0, backupResults.Errors.Count());
+                Assert.AreEqual(0, backupResults.Warnings.Count());
+            }
+
+            // Restore all files.
+            Dictionary<string, string> restoreOptions = new Dictionary<string, string>(options) {["restore-path"] = this.RESTOREFOLDER};
+            using (Controller c = new Controller("file://" + this.TARGETFOLDER, restoreOptions, null))
+            {
+                IRestoreResults restoreResults = c.Restore(null);
+                Assert.AreEqual(0, restoreResults.Errors.Count());
+                Assert.AreEqual(0, restoreResults.Warnings.Count());
+
+                foreach (string directory in directories)
+                {
+                    string directoryName = SystemIO.IO_OS.PathGetFileName(directory);
+                    foreach (string expectedFilePath in SystemIO.IO_OS.EnumerateFiles(directory))
+                    {
+                        string fileName = SystemIO.IO_OS.PathGetFileName(expectedFilePath);
+                        string restoredFilePath = SystemIO.IO_OS.PathCombine(this.RESTOREFOLDER, directoryName, fileName);
+                        Assert.IsTrue(TestUtils.CompareFiles(expectedFilePath, restoredFilePath, expectedFilePath, false));
+                    }
+                }
+
+                // List results using * should return a match for each directory.
+                IListResults listResults = c.List(SystemIO.IO_OS.PathCombine(dirWithAsterisk, file));
+                Assert.AreEqual(0, listResults.Errors.Count());
+                Assert.AreEqual(0, listResults.Warnings.Count());
+                Assert.AreEqual(directories.Count, listResults.Files.Count());
+
+                // List results using ? should return 2 matches, one for the directory with '*' and one for the directory with '?'.
+                listResults = c.List(SystemIO.IO_OS.PathCombine(dirWithQuestionMark, file));
+                Assert.AreEqual(0, listResults.Errors.Count());
+                Assert.AreEqual(0, listResults.Warnings.Count());
+                Assert.AreEqual(2, listResults.Files.Count());
+            }
+
+            SystemIO.IO_OS.DirectoryDelete(this.RESTOREFOLDER, true);
+
+            // Restore one file at a time using the verbatim identifier.
+            foreach (string directory in directories)
+            {
+                foreach (string expectedFilePath in SystemIO.IO_OS.EnumerateFiles(directory))
+                {
+                    using (Controller c = new Controller("file://" + this.TARGETFOLDER, restoreOptions, null))
+                    {
+                        string verbatimFilePath = "@" + expectedFilePath;
+
+                        // Verify that list result using verbatim identifier contains only one file.
+                        IListResults listResults = c.List(verbatimFilePath);
+                        Assert.AreEqual(0, listResults.Errors.Count());
+                        Assert.AreEqual(0, listResults.Warnings.Count());
+                        Assert.AreEqual(1, listResults.Files.Count());
+                        Assert.AreEqual(expectedFilePath, listResults.Files.Single().Path);
+
+                        IRestoreResults restoreResults = c.Restore(new[] {verbatimFilePath});
+                        Assert.AreEqual(0, restoreResults.Errors.Count());
+                        Assert.AreEqual(0, restoreResults.Warnings.Count());
+
+                        string fileName = SystemIO.IO_OS.PathGetFileName(expectedFilePath);
+                        string restoredFilePath = SystemIO.IO_OS.PathCombine(this.RESTOREFOLDER, fileName);
+                        Assert.IsTrue(TestUtils.CompareFiles(expectedFilePath, restoredFilePath, expectedFilePath, false));
+
+                        SystemIO.IO_OS.FileDelete(restoredFilePath);
+                    }
+                }
+            }
+
+            // Backup with asterisk in include filter should include all directories.
+            FilterExpression filter = new FilterExpression(dirWithAsterisk);
+            using (Controller c = new Controller("file://" + this.TARGETFOLDER, options, null))
+            {
+                IBackupResults backupResults = c.Backup(new[] {this.DATAFOLDER}, filter);
+                Assert.AreEqual(0, backupResults.Errors.Count());
+                Assert.AreEqual(0, backupResults.Warnings.Count());
+                Assert.AreEqual(directories.Count, backupResults.ExaminedFiles);
+            }
+
+            // Backup with verbatim asterisk in include filter should include one directory.
+            filter = new FilterExpression("@" + SystemIO.IO_OS.PathCombine(dirWithAsterisk, file));
+            using (Controller c = new Controller("file://" + this.TARGETFOLDER, options, null))
+            {
+                IBackupResults backupResults = c.Backup(new[] {this.DATAFOLDER}, filter);
+                Assert.AreEqual(0, backupResults.Errors.Count());
+                Assert.AreEqual(0, backupResults.Warnings.Count());
+                Assert.AreEqual(1, backupResults.ExaminedFiles);
+            }
+        }
+
+        [Test]
+        [Category("ProblematicPath")]
         public void ExcludeProblematicPaths()
         {
             // A normal path that will be backed up.