public void ExplicitlyExcludedNonexistantFileNotFiltered()
        {
            using (var bob = new RepositorySetup("bob"))
            {
                const string largeDictionaryFilename = "ghost.dic";
                var largeDictionaryPathname = Path.Combine("nestedFolder", largeDictionaryFilename);
                var fullDictionaryPathname = Path.Combine(bob.ProjectFolderConfig.FolderPath, largeDictionaryPathname);
                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;
                const string randomFile = "random.txt";
                bob.ChangeFile(randomFile, "Some text.");
                var fullRandomPathname = Path.Combine(bob.ProjectFolderConfig.FolderPath, randomFile);
                bob.Repository.TestOnlyAddSansCommit(fullRandomPathname);

                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                config.ExcludePatterns.Add(Path.Combine("nestedFolder", "ghost.dic"));
                config.IncludePatterns.Clear();
                config.IncludePatterns.Add("**.*");

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    ChorusFileTypeHandlerCollection.CreateWithInstalledHandlers());
                Assert.IsTrue(string.IsNullOrEmpty(result));
                var shortpath = fullDictionaryPathname.Replace(pathToRepo, "");
                Assert.IsTrue(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));

                shortpath = fullRandomPathname.Replace(pathToRepo, "");
                Assert.IsFalse(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
            }
        }
Beispiel #2
0
        public void ChangedUtf8File_FileCanBePulledAndUpdated()
        {
            using (var setup = new RepositorySetup("Dan"))
            {
                const string utf8FilePath = "açesbsun.wav";
                setup.ChangeFile(utf8FilePath, "hello1");
                setup.ProjectFolderConfig.IncludePatterns.Add("*.wav");
                setup.AddAndCheckIn();

                using (var other = new RepositorySetup("Bob", setup))
                {
                    setup.ChangeFile(utf8FilePath, "hello2");
                    setup.Repository.Commit(false, "update");
                    other.CheckinAndPullAndMerge(setup); // Fix: Currently this modifies Dan adding bogus file unexpectedly.
                    other.AssertFileExists(utf8FilePath);
                    string[] fileNames = Directory.GetFiles(other.ProjectFolder.Path, "*.wav");
                    Assert.AreEqual(1, fileNames.Length);
                }

            }
        }
Beispiel #3
0
        public void AddUtf8FileName_CloneUpdatedFileExists()
        {
            using (var setup = new RepositorySetup("Dan"))
            {
                const string utf8FilePath = "açesbsun.wav";
                setup.ChangeFile(utf8FilePath, "hello");
                setup.ProjectFolderConfig.IncludePatterns.Add("*.wav");
                setup.AddAndCheckIn();

                using (var other = new RepositorySetup("Bob", setup))
                {
                    other.AssertFileExists(utf8FilePath);
                }

            }
        }
Beispiel #4
0
 public void SecondCheckin_Invalid_BacksOut()
 {
     using (var bob = new RepositorySetup("bob"))
     {
         bob.AddAndCheckinFile("test.chorusTest", "hello");
         bob.ChangeFile("test.chorusTest",ChorusTestFileHandler.GetInvalidContents());
         using (var cop = new CommitCop(bob.Repository, ChorusFileTypeHandlerCollection.CreateWithTestHandlerOnly(), bob.Progress))
         {
             Assert.IsFalse(string.IsNullOrEmpty(cop.ValidationResult));
             bob.Repository.Commit(false, "bad data");
         }
         Debug.WriteLine(bob.Repository.GetLog(-1));
         bob.AssertHeadCount(1);
         bob.AssertLocalRevisionNumber(2);
         bob.AssertFileContents("test.chorusTest", "hello");
     }
 }
Beispiel #5
0
 public void HasFileHandlers_ValidCommit_Validates_DoesNothing()
 {
     using(var bob = new RepositorySetup("bob"))
     {
         bob.AddAndCheckinFile("test.chorusTest", "hello");
         using(var cop = new CommitCop(bob.Repository, ChorusFileTypeHandlerCollection.CreateWithTestHandlerOnly(), bob.Progress))
         {
             bob.ChangeFile("test.chorusTest", "aloha");
             bob.AddAndCheckinFile("test2.chorusTest", "hi");
             Assert.IsNullOrEmpty(cop.ValidationResult);
         }
         bob.AssertHeadCount(1);
         bob.AssertLocalRevisionNumber(1);
         bob.AssertFileExistsInRepository("test2.chorusTest");
         bob.AssertFileContents("test.chorusTest", "aloha");
         bob.AssertFileContents("test2.chorusTest", "hi");
     }
 }
Beispiel #6
0
 public void InitialFileCommit_Invalid_BacksOut()
 {
     using(var bob = new RepositorySetup("bob"))
     {
         bob.AddAndCheckinFile("validfile.chorustest", "valid contents");
         bob.ChangeFile("test.chorusTest", ChorusTestFileHandler.GetInvalidContents());
         using(var cop = new CommitCop(bob.Repository, ChorusFileTypeHandlerCollection.CreateWithTestHandlerOnly(), bob.Progress))
         {
             bob.Repository.AddAndCheckinFile("test.chorusTest");
             Assert.That(cop.ValidationResult, Is.StringContaining("Failed"));
         }
         Debug.WriteLine(bob.Repository.GetLog(-1));
         bob.AssertHeadCount(1);
         bob.AssertLocalRevisionNumber(2);
         bob.AssertFileDoesNotExistInRepository("test.chorusTest");
         bob.AssertFileExistsInRepository("validfile.chorustest");
     }
 }
        public void FileWithSpecialCharacterIsAllowed()
        {
            using (var bob = new RepositorySetup("bob"))
            {
                const string fileName =  "ŭburux.wav";
                bob.ChangeFile(fileName, _goodData);
                var fullPathname = Path.Combine(bob.ProjectFolderConfig.FolderPath, fileName);
                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;
                bob.Repository.TestOnlyAddSansCommit(fullPathname);
                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                config.IncludePatterns.Clear();
                config.IncludePatterns.Add("**.wav");

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    _handlersColl);
                Assert.IsTrue(string.IsNullOrEmpty(result));
                var shortpath = fullPathname.Replace(pathToRepo, "");
                Assert.IsFalse(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
            }
        }
Beispiel #8
0
 public void VeryFirstCommit_Invalid_Throws()
 {
     string validationResult = null;
     Assert.Throws<ApplicationException>(() =>
     {
         using(var bob = new RepositorySetup("bob"))
         {
             bob.ChangeFile("test.chorusTest", ChorusTestFileHandler.GetInvalidContents());
             using(var cop = new CommitCop(bob.Repository, ChorusFileTypeHandlerCollection.CreateWithTestHandlerOnly(), bob.Progress))
             {
                 bob.Repository.AddAndCheckinFile("test.chorusTest");
                 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed - SUT
                 validationResult = cop.ValidationResult;
             }
         }
     });
     Assert.That(validationResult, Is.StringContaining("Failed"));
 }
        public void LongModifiedFileIsfilteredOut()
        {
            // File is in repo in its shorter version, but now it has grown too large.
            using (var bob = new RepositorySetup("bob"))
            {
                const string fileName = "test.chorusTest";
                bob.ChangeFile(fileName, _goodData);
                var fullPathname = Path.Combine(bob.ProjectFolderConfig.FolderPath, fileName);
                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;
                bob.Repository.AddAndCheckinFile(fullPathname);
                bob.AssertLocalRevisionNumber(0);
                bob.AssertFileContents(fullPathname, _goodData);

                bob.ChangeFile(fileName, _longData);

                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                config.IncludePatterns.Clear();
                config.IncludePatterns.Add("**.chorusTest");

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    _handlersColl);
                bob.Repository.Commit(false, "test");
                bob.AssertLocalRevisionNumber(1); // 'forget' marks it as deleted in the repo.
                bob.AssertFileContents(fullPathname, _longData);

                Assert.IsFalse(string.IsNullOrEmpty(result));
                var shortpath = fullPathname.Replace(pathToRepo, "");
                Assert.IsTrue(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
            }
        }
        public void LargeMp3FileIsNotAllowed()
        {
            using (var bob = new RepositorySetup("bob"))
            {
                const string fileName = "whopper.Mp3";
                var megabyteLongData = "long" + Environment.NewLine;
                while (megabyteLongData.Length < LargeFileFilter.Megabyte)
                    megabyteLongData += megabyteLongData;
                bob.ChangeFile(fileName, megabyteLongData);
                var fullPathname = Path.Combine(bob.ProjectFolderConfig.FolderPath, fileName);
                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;
                bob.Repository.TestOnlyAddSansCommit(fileName);
                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                config.IncludePatterns.Clear();
                LiftFolder.AddLiftFileInfoToFolderConfiguration(config);

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    ChorusFileTypeHandlerCollection.CreateWithInstalledHandlers());
                Assert.IsFalse(string.IsNullOrEmpty(result));
                var shortpath = fullPathname.Replace(pathToRepo, "");
                Assert.IsTrue(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
            }
        }
Beispiel #11
0
        public void Utf8ExtensionPresent_LocalMercurialIniIncorrect_MercurialOpStillWorks()
        {
            using (new MercurialIniHider())
            using (var setup = new RepositorySetup("Dan"))
            {
                const string utf8FilePath = "açesbsun.wav";
                setup.ChangeFile(utf8FilePath, "hello1");
                setup.ProjectFolderConfig.IncludePatterns.Add("*.wav");
                setup.AddAndCheckIn();

                setup.AssertFileExistsInRepository("açesbsun.wav");

            }
        }
        public void LongUnknownFileIsfilteredOut()
        {
            using (var bob = new RepositorySetup("bob"))
            {
                const string fileName = "test.chorusTest";
                bob.ChangeFile(fileName, _longData);
                var fullPathname = Path.Combine(bob.ProjectFolderConfig.FolderPath, fileName);
                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;

                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                config.IncludePatterns.Clear();
                config.IncludePatterns.Add("**.chorusTest");

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    _handlersColl);
                Assert.IsFalse(string.IsNullOrEmpty(result));
                var shortpath = fullPathname.Replace(pathToRepo, "");
                Assert.IsTrue(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
            }
        }
Beispiel #13
0
        public void Utf8ExtensionPresent_CloneDoesNotHaveBogusFiles()
        {
            using (var setup = new RepositorySetup("Dan"))
            {
                const string utf8FilePath = "açesbsun.wav";
                setup.ChangeFile(utf8FilePath, "hello1");
                setup.ProjectFolderConfig.IncludePatterns.Add("*.wav");
                setup.AddAndCheckIn();

                using (var other = new RepositorySetup("Bob", false))
                {
                    //var uri = new Uri(String.Format("file:///{0}", setup.ProjectFolder.Path));
                    HgRepository.Clone(new HttpRepositoryPath("utf test repo", setup.ProjectFolder.Path, false), other.ProjectFolder.Path, other.Progress);
                    other.Repository.Update();

                    other.AssertFileExists(utf8FilePath);
                    string[] fileNames = Directory.GetFiles(other.ProjectFolder.Path, "*.wav");
                    Assert.AreEqual(1, fileNames.Length);

                    //Assert.IsTrue(setup.GetProgressString().Contains());
                }

            }
        }
Beispiel #14
0
        public void Utf8ExtensionPresent_CloneLocalWithUpdateDoesNotHaveBogusFiles()
        {
            using (var setup = new RepositorySetup("Dan"))
            {
                const string utf8FilePath = "açesbsun.wav";
                setup.ChangeFile(utf8FilePath, "hello1");
                setup.ProjectFolderConfig.IncludePatterns.Add("*.wav");
                setup.AddAndCheckIn();

                using (var other = new RepositorySetup("Bob", false))
                {
                    setup.Repository.CloneLocalWithoutUpdate(other.ProjectFolder.Path); // Somewhat surprisingly this works as it is using the settings of the source hgrc during the clone
                    other.Repository.Update();

                    other.AssertFileExists(utf8FilePath);
                    string[] fileNames = Directory.GetFiles(other.ProjectFolder.Path, "*.wav");
                    Assert.AreEqual(1, fileNames.Length);

                    //Assert.IsTrue(setup.GetProgressString().Contains());
                }

            }
        }
        public void Sync_ModifiedFileIsInvalid_CheckedInButThenBackedOut()
        {
            /*
                @  changeset:   2
                |  summary:     [Backout due to validation Failure]
                |
                o  changeset:   1
                |  summary:     missing checkin description
                |
                o  changeset:   0
                summary:     Add test.chorusTest
             */
            using (var bob = new RepositorySetup("bob"))
            {
                bob.AddAndCheckinFile("test.chorusTest", "original");
                bob.AssertLocalRevisionNumber(0);
                bob.ChangeFile("test.chorusTest", ChorusTestFileHandler.GetInvalidContents());
                bob.CheckinAndPullAndMerge();
                bob.AssertLocalRevisionNumber(2);
                bob.AssertHeadCount(1);  
                bob.AssertLocalRevisionNumber(int.Parse(bob.Repository.GetTip().Number.LocalRevisionNumber));
                Debug.WriteLine(bob.Repository.GetLog(-1));

            }
        }
        public void LargeFileInExcludedNestedPathIsNotFilteredOut()
        {
            using (var bob = new RepositorySetup("bob"))
            {
                var megabyteLongData = "long" + Environment.NewLine;
                while (megabyteLongData.Length < LargeFileFilter.Megabyte)
                    megabyteLongData += megabyteLongData;

                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;
                var firstLayer = Path.Combine(bob.Repository.PathToRepo, "SomeLayer");
                Directory.CreateDirectory(firstLayer);
                var nestedFolder = Path.Combine(firstLayer, "Cache");
                Directory.CreateDirectory(nestedFolder);
                const string largeVideoFilename = "whopper.mov";
                var largeVideoPathname = Path.Combine(nestedFolder, largeVideoFilename);
                bob.ChangeFile(largeVideoPathname, megabyteLongData);
                bob.Repository.TestOnlyAddSansCommit(largeVideoPathname);

                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                //config.ExcludePatterns.Add(Path.Combine("**", "Cache"));
                config.ExcludePatterns.Add("**Cache");
                config.IncludePatterns.Clear();
                config.IncludePatterns.Add("**.*");

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    ChorusFileTypeHandlerCollection.CreateWithInstalledHandlers());
                Assert.IsTrue(string.IsNullOrEmpty(result));

                var shortpath = largeVideoPathname.Replace(pathToRepo, "");
                Assert.IsFalse(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
            }
        }
        public void LongWavFileIsFilteredOutAndNotInRepo()
        {
            using (var bob = new RepositorySetup("bob"))
            {
                var megabyteLongData = "long" + Environment.NewLine;
                while (megabyteLongData.Length < LargeFileFilter.Megabyte)
                    megabyteLongData += megabyteLongData;

                const string fileName = "big.wav";
                bob.ChangeFile(fileName, megabyteLongData);
                var fullPathname = Path.Combine(bob.ProjectFolderConfig.FolderPath, fileName);
                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;
                bob.Repository.TestOnlyAddSansCommit(fullPathname);
                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                config.IncludePatterns.Clear();
                config.IncludePatterns.Add("**.wav");

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    ChorusFileTypeHandlerCollection.CreateWithInstalledHandlers());
                Assert.IsFalse(string.IsNullOrEmpty(result));
                var shortpath = fullPathname.Replace(pathToRepo, "");
                Assert.IsTrue(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
                bob.Repository.AddAndCheckinFiles(config.IncludePatterns, config.ExcludePatterns, "Some commit");
                bob.AssertFileDoesNotExistInRepository("big.wav");
            }
        }
        public void SmallFileInNonExcludedFolderNotFilteredByExclusionAtDeeperNesting()
        {
            //Put a small file in [repo]\Cache and a large file in [repo]\foo\SomeLayer\Cache
            //exclude \foo\**\Cache, make sure that [repo]\Cache\smallFile was not filtered out.
            // Make sure that [repo]\foo\SomeLayer\Cache\largfile was not reported as being a large file.
            using (var bob = new RepositorySetup("bob"))
            {
                var smallData = "small" + Environment.NewLine;
                while (smallData.Length < LargeFileFilter.Megabyte / 3)
                    smallData += smallData;
                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;
                var cacheAtRoot = Path.Combine(bob.Repository.PathToRepo, "Cache");
                Directory.CreateDirectory(cacheAtRoot);
                const string smallVideoFilename = "dinky.mov";
                var smallNestedVideoPathname = Path.Combine(cacheAtRoot, smallVideoFilename);
                bob.ChangeFile(smallNestedVideoPathname, smallData);
                bob.Repository.TestOnlyAddSansCommit(smallNestedVideoPathname);

                var megabyteLongData = "long" + Environment.NewLine;
                while (megabyteLongData.Length < LargeFileFilter.Megabyte)
                    megabyteLongData += megabyteLongData;
                var fooAtRoot = Path.Combine(bob.Repository.PathToRepo, "foo");
                Directory.CreateDirectory(fooAtRoot);
                var firstLayerBelowFoo = Path.Combine(fooAtRoot, "SomeLayer");
                Directory.CreateDirectory(firstLayerBelowFoo);
                var nestedCacheFolder = Path.Combine(firstLayerBelowFoo, "Cache");
                Directory.CreateDirectory(nestedCacheFolder);
                const string largeVideoFilename = "whopper.mov";
                var largeNestedVideoPathname = Path.Combine(nestedCacheFolder, largeVideoFilename);
                bob.ChangeFile(largeNestedVideoPathname, megabyteLongData);
                bob.Repository.TestOnlyAddSansCommit(largeNestedVideoPathname);

                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                config.ExcludePatterns.Add(Path.Combine("foo", Path.Combine("**", "Cache")));
                config.IncludePatterns.Clear();
                config.IncludePatterns.Add("**.*");

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    ChorusFileTypeHandlerCollection.CreateWithInstalledHandlers());
                Assert.True(string.IsNullOrEmpty(result), @"Cache folder at root was improperly filtered by foo\**\Cache");

                var shortpath = largeNestedVideoPathname.Replace(pathToRepo, null);
                Assert.IsFalse(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));

                shortpath = smallNestedVideoPathname.Replace(pathToRepo, null);
                Assert.IsFalse(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
            }
        }
        public void NormallyExcludedNestedLargeFileIsNotAddedByLargeFileFilter()
        {
            using (var bob = new RepositorySetup("bob"))
            {
                var megabyteLongData = "long" + Environment.NewLine;
                while (megabyteLongData.Length < LargeFileFilter.Megabyte)
                    megabyteLongData += megabyteLongData;

                const string largeDictionaryFilename = "whopper.dic";
                var nestedFolder = Path.Combine(bob.Repository.PathToRepo, "nestedFolder");
                Directory.CreateDirectory(nestedFolder);
                var largeDictionaryPathname = Path.Combine("nestedFolder", largeDictionaryFilename);

                bob.ChangeFile(largeDictionaryPathname, megabyteLongData);
                var fullDictionaryPathname = Path.Combine(bob.ProjectFolderConfig.FolderPath, largeDictionaryPathname);
                var pathToRepo = bob.Repository.PathToRepo + Path.DirectorySeparatorChar;
                bob.Repository.TestOnlyAddSansCommit(fullDictionaryPathname);

                var config = bob.ProjectFolderConfig;
                config.ExcludePatterns.Clear();
                config.ExcludePatterns.Add(Path.Combine("nestedFolder", "whopper.dic"));
                config.IncludePatterns.Clear();
                config.IncludePatterns.Add("**.*");

                var result = LargeFileFilter.FilterFiles(
                    bob.Repository,
                    config,
                    ChorusFileTypeHandlerCollection.CreateWithInstalledHandlers());
                Assert.IsTrue(string.IsNullOrEmpty(result));
                var shortpath = fullDictionaryPathname.Replace(pathToRepo, "");
                Assert.IsTrue(config.ExcludePatterns.Contains(shortpath));
                Assert.IsFalse(config.IncludePatterns.Contains(shortpath));
            }
        }
        public void GetFilteredStatusForFilesHasExpectedResults()
        {
            using (var repo = new RepositorySetup("BigFiles", true))
            {
                // 'clean' - C
                repo.AddAndCheckinFile("control.txt", "original");
                repo.AddAndCheckinFile("modified.txt", "original");
                repo.AddAndCheckinFile("removed.txt", "removed properly");
                repo.AddAndCheckinFile("goner.txt", "short lived");
                File.WriteAllText(Path.Combine(repo.ProjectFolder.Path, "added.txt"), "added file");

                // 'modified' - M
                repo.ChangeFile("modified.txt", "updated");

                // 'added' - A
                repo.Repository.Execute(10, "add", "added.txt");

                // 'removed' - R
                repo.Repository.Execute(10, "rm", "removed.txt");

                // 'missing' - !
                File.Delete(Path.Combine(repo.ProjectFolder.Path, "goner.txt"));

                // 'unknown' - ?
                File.WriteAllText(Path.Combine(repo.ProjectFolder.Path, "unknown.txt"), "new data");

                // excluded
                File.WriteAllText(Path.Combine(repo.ProjectFolder.Path, "unknown.jpg"), "some binary data");

                repo.ProjectFolderConfig.ExcludePatterns.Add("*.jpg");
                repo.ProjectFolderConfig.IncludePatterns.Add("*.txt");

                var results = LargeFileFilter.GetStatusOfFilesOfInterest(repo.Repository, repo.ProjectFolderConfig);
                Assert.AreEqual(3, results.Keys.Count);
                Assert.IsTrue(results.ContainsKey("M")); // tracked and modifed
                Assert.IsTrue(results.ContainsKey("A")); // Added with hg add
                Assert.IsTrue(results.ContainsKey("?")); // untracked

                foreach (var resultKvp in results)
                {
                    var resultValue = resultKvp.Value;
                    Assert.AreEqual(1, resultValue.Keys.Count);
                    Assert.IsTrue(resultValue.ContainsKey("txt"));
                    Assert.AreEqual(1, resultValue.Values.Count);
                    switch (resultKvp.Key)
                    {
                        case "M":
                            Assert.AreEqual("modified.txt", resultValue["txt"][0]);
                            break;
                        case "A":
                            Assert.AreEqual("added.txt", resultValue["txt"][0]);
                            break;
                        case "?":
                            Assert.AreEqual("unknown.txt", resultValue["txt"][0]);
                            break;
                    }
                }
            }
        }
Beispiel #21
0
        #if !MONO

        [Test]
        public void Utf8ExtensionNotPresent_CloneLocalWithoutUpdateThrows()
        {
            using (var setup = new RepositorySetup("Dan"))
            {
                const string utf8FilePath = "açesbsun.wav";
                setup.ChangeFile(utf8FilePath, "hello1");
                setup.ProjectFolderConfig.IncludePatterns.Add("*.wav");
                setup.AddAndCheckIn();

                using (new MercurialExtensionHider())
                using (var other = new RepositorySetup("Bob", false))
                {
                    Assert.Throws<ApplicationException>(
                        () => setup.Repository.CloneLocalWithoutUpdate(other.ProjectFolder.Path)
                    );
                    //string log = setup.GetProgressString();
                    //Assert.That(log, Contains.Substring("Failed to set up extensions"));
                    //Assert.IsTrue(setup.GetProgressString().Contains());
                }