C# MockFileSystem.FileExists方法代码示例

        public void CallAddPackageWillAddNupkgFileButNoNuspecFile(string id, string version, string nuspecPath, string nupkgPath)
        {
            // Arrange
            var fileSystem = new MockFileSystem("x:\\root");
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
            
            // Act            
            repository.AddPackage(PackageUtility.CreatePackage(id, version));

            // Assert
            Assert.False(fileSystem.FileExists(nuspecPath));
            Assert.True(fileSystem.FileExists(nupkgPath));
        }

        public void CallAddPackageWillAddNuspecWhichHasReferencesData()
        {
            // Arrange
            var fileSystem = new MockFileSystem("x:\\root");
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);

            // Act
            repository.AddPackage(PackageUtility.CreatePackage("A",
                                                               "1.0",
                                                               assemblyReferences: new[] { "lib\\net40\\A.dll", "lib\\B.dll" }));

            // Assert
            Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));

            Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
            Manifest manifest = Manifest.ReadFrom(manifestContentStream, validateSchema: true);

            Assert.Equal(2, manifest.Metadata.ReferenceSets.Count);

            var set1 = manifest.Metadata.ReferenceSets[0];
            Assert.Equal(".NETFramework4.0", set1.TargetFramework);
            Assert.Equal(1, set1.References.Count);
            Assert.Equal("A.dll", set1.References[0].File);

            var set2 = manifest.Metadata.ReferenceSets[1];
            Assert.Null(set2.TargetFramework);
            Assert.Equal(1, set2.References.Count);
            Assert.Equal("B.dll", set2.References[0].File);
        }

        public void InstallCommandInstallsPackageIfArgumentIsNotPackageReferenceFile()
        {
            // Arrange
            var fileSystem = new MockFileSystem();
            var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
            installCommand.Arguments.Add("Foo");

            // Act
            installCommand.ExecuteCommand();

            // Assert
            Assert.True(fileSystem.FileExists(@"Foo.1.0\Foo.1.0.nupkg"));
        }

        public void CallRemovePackageWillRemoveNuspecFile(string id, string version, string unexpectedPath)
        {
            // Arrange
            var fileSystem = new MockFileSystem("x:\root");
            fileSystem.AddFile(unexpectedPath);
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);

            // Act
            repository.RemovePackage(PackageUtility.CreatePackage(id, version));

            // Assert
            Assert.False(fileSystem.FileExists(unexpectedPath));
        }

        public void CallAddPackageWillAddNuspecWithReferencesPreserved()
        {
            // Arrange
            var fileSystem = new MockFileSystem("x:\\root");
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);

            // Act
            var package = PackageUtility.CreatePackage("A", "1.0", content: new[] { "A.txt", "scripts\\b.txt" });
            var mockedPackage = Mock.Get(package);
            mockedPackage.Setup(m => m.PackageAssemblyReferences).Returns(
                new PackageReferenceSet[] { 
                    new PackageReferenceSet(new FrameworkName(".NETFramework, Version=4.0"), new [] { "A.dll" }),
                    new PackageReferenceSet(null, new [] { "B.dll" }),
                });

            // Act
            repository.AddPackage(package);

            // Assert
            Assert.False(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));
            Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nupkg"));
        }

        public void CallAddPackageWillNotCreatePackageConfigEntryToPackageConfig()
        {
            // Arrange
            var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
            fileSystem.Setup(m => m.Root).Returns(@"c:\foo\");
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, configFileSystem);

            // Act
            repository.AddPackage(PackageUtility.CreatePackage("A", "2.0"));

            // Assert
            Assert.False(configFileSystem.FileExists("packages.config"));
        }

        public void DeleteFileAndEmptyParentDirectoriesCorrectly()
        {
            // Arrange
            var fileSystem = new MockFileSystem("x:\\");
            fileSystem.AddFile("foo\\bar\\hell\\x.txt");

            // Act
            fileSystem.DeleteFileAndParentDirectoriesIfEmpty("foo\\bar\\hell\\x.txt");

            // Assert
            Assert.False(fileSystem.FileExists("foo\\bar\\hell\\x.txt"));
            Assert.False(fileSystem.DirectoryExists("foo"));
            Assert.False(fileSystem.DirectoryExists("foo\\bar"));
            Assert.False(fileSystem.DirectoryExists("foo\\bar\\hell"));
        }

        public void MarkPackageDirectoryForDeletionDoesNotAddDeletemeFileWhenDirectoryRemovalSuccessful()
        {
            // Arrange
            IPackage package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0.0");
            var fileSystem = new MockFileSystem();
            var pathResolver = new DefaultPackagePathResolver(fileSystem);
            string packageDirectoryPath = pathResolver.GetPackageDirectory(package);

            var deleteOnRestartManager = new DeleteOnRestartManager(() => fileSystem, () => pathResolver);

            // Act
            deleteOnRestartManager.MarkPackageDirectoryForDeletion(package, _ => package);

            // Assert
            Assert.False(fileSystem.DirectoryExists(packageDirectoryPath));
            Assert.False(fileSystem.FileExists(packageDirectoryPath + _deletionMarkerSuffix));
        }

        public void AddedNuspecDoesNotAddReferencesSectionIfNotPresent()
        {
            // Arrange
            var fileSystem = new MockFileSystem("x:\\root");
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);

            // Act
            var package = PackageUtility.CreatePackage("A", "1.0", content: new[] { "A.txt", "scripts\\b.txt" });
            repository.AddPackage(package);

            // Assert
            Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));

            Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
            Manifest manifest = Manifest.ReadFrom(manifestContentStream, validateSchema: true);

            Assert.Equal(0, manifest.Metadata.ReferenceSets.Count);
        }

        public void MarkPackageDirectoryForDeletionDoesNotAddDeletemeFileWhenFileModified()
        {
            // Arrange
            IPackage package = NuGet.Test.PackageUtility.CreatePackage(id: "foo", version: "1.0.0", content: new string[] {}, assemblyReferences: new string[] {}, tools: new[] { "modifiedFile.txt" });
            var fileSystem = new MockFileSystem();
            var pathResolver = new DefaultPackagePathResolver(fileSystem);
            string packageDirectoryPath = pathResolver.GetPackageDirectory(package);
            string modifiedFilePath = Path.Combine("tools", "modifiedFile.txt");

            fileSystem.AddFile(Path.Combine(packageDirectoryPath, pathResolver.GetPackageFileName(package)), Stream.Null);
            fileSystem.AddFile(Path.Combine(packageDirectoryPath, modifiedFilePath), "Modified Content".AsStream());

            var deleteOnRestartManager = new DeleteOnRestartManager(() => fileSystem, () => pathResolver);

            // Act
            deleteOnRestartManager.MarkPackageDirectoryForDeletion(package, _ => package);

            // Assert
            Assert.True(fileSystem.DirectoryExists(packageDirectoryPath));
            Assert.True(fileSystem.FileExists(Path.Combine(packageDirectoryPath, modifiedFilePath)));
            Assert.False(fileSystem.FileExists(packageDirectoryPath + _deletionMarkerSuffix));
        }

        public void CallAddPackageWillNotAddEntryToPackageConfigWhenPackageConfigAlreadyExists()
        {
            // Arrange
            var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
            fileSystem.Setup(m => m.Root).Returns(@"c:\foo\");
            var configFileSystem = new MockFileSystem();
            configFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
  <package id=""A"" version=""2.0"" />
</packages>");
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, configFileSystem);

            // Act
            repository.AddPackage(PackageUtility.CreatePackage("B", "1.0"));

            // Assert
            Assert.True(configFileSystem.FileExists("packages.config"));
            Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
  <package id=""A"" version=""2.0"" />
</packages>", configFileSystem.ReadAllText("packages.config"));
        }

        public void AddPackageDoesNotAddEntryToPackagesConfigIfExists()
        {
            // Arrange
            var sharedRepository = new Mock<ISharedPackageRepository>();
            var fileSystem = new MockFileSystem();
            fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
            <packages>
              <package id=""A"" version=""1.0"" />
            </packages>");
            var referenceRepository = new PackageReferenceRepository(fileSystem, sharedRepository.Object);
            var package = PackageUtility.CreatePackage("A");

            // Act
            referenceRepository.AddPackage(package);

            // Assert
            Assert.IsTrue(fileSystem.FileExists("packages.config"));
            Assert.AreEqual(@"<?xml version=""1.0"" encoding=""utf-8""?>
            <packages>
              <package id=""A"" version=""1.0"" />
            </packages>", fileSystem.ReadAllText("packages.config"));
        }

        public void AddPackageAddsEntryToPackagesConfig()
        {
            // Arrange
            var sharedRepository = new Mock<ISharedPackageRepository>();
            string path = null;
            sharedRepository.Setup(m => m.RegisterRepository(It.IsAny<string>()))
                            .Callback<string>(p => path = p);
            var fileSystem = new MockFileSystem();
            var referenceRepository = new PackageReferenceRepository(fileSystem, sharedRepository.Object);
            var package = PackageUtility.CreatePackage("A");

            // Act
            referenceRepository.AddPackage(package);

            // Assert
            Assert.Equal(@"C:\MockFileSystem\packages.config", path);
            Assert.True(fileSystem.FileExists("packages.config"));
            Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
  <package id=""A"" version=""1.0"" />
</packages>", fileSystem.ReadAllText("packages.config"));
        }

        public void CallAddPackageWillAddNuspecWhichHasReferencesData()
        {
            // Arrange
            var fileSystem = new MockFileSystem("x:\root");
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);

            // Act
            repository.AddPackage(PackageUtility.CreatePackage("A", 
                                                               "1.0", 
                                                               assemblyReferences: new [] { "net40\\A.dll", "sl45\\B.dll", "A.dll", "win8\\C.dll" }));

            // Assert
            Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));

            Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
            Manifest manifest = Manifest.ReadFrom(manifestContentStream);

            Assert.Equal(3, manifest.Metadata.References.Count);
            Assert.Equal("A.dll", manifest.Metadata.References[0].File);
            Assert.Equal("B.dll", manifest.Metadata.References[1].File);
            Assert.Equal("C.dll", manifest.Metadata.References[2].File);
        }

        public void CallAddPackageWillAddNuspecWithReferencesPreserved()
        {
            // Arrange
            var fileSystem = new MockFileSystem("x:\\root");
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);

            // Act
            var package = PackageUtility.CreatePackage("A", "1.0", content: new[] { "A.txt", "scripts\\b.txt" });
            var mockedPackage = Mock.Get(package);
            mockedPackage.Setup(m => m.PackageAssemblyReferences).Returns(
                new PackageReferenceSet[] { 
                    new PackageReferenceSet(new FrameworkName(".NETFramework, Version=4.0"), new [] { "A.dll" }),
                    new PackageReferenceSet(null, new [] { "B.dll" }),
                });

            repository.AddPackage(package);

            // Assert
            Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));

            Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
            Manifest manifest = Manifest.ReadFrom(manifestContentStream, validateSchema: true);

            Assert.Equal(2, manifest.Metadata.ReferenceSets.Count);

            var set1 = manifest.Metadata.ReferenceSets[0];
            Assert.Equal(".NETFramework4.0", set1.TargetFramework);
            Assert.Equal(1, set1.References.Count);
            Assert.Equal("A.dll", set1.References[0].File);

            var set2 = manifest.Metadata.ReferenceSets[1];
            Assert.Null(set2.TargetFramework);
            Assert.Equal(1, set2.References.Count);
            Assert.Equal("B.dll", set2.References[0].File);
        }