C# SharedPackageRepository类代码示例

        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 GetRepositoryPathsRemovesInvalidOrNonExistantPathsAndReturnsRelativePaths()
        {
            // Arrange
            var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
            fileSystem.Setup(m => m.FileExists(@"A\packages.config")).Returns(true);
            fileSystem.Setup(m => m.FileExists(@"c:\foo\packages.config")).Returns(true);
            fileSystem.Setup(m => m.FileExists(@"..\..\packages.config")).Returns(true);
            fileSystem.Object.AddFile("repositories.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
  <repository path=""A\packages.config"" />
  <repository path=""B\packages.config"" />
  <repository path=""c:\foo\packages.config"" />
  <repository path=""..\..\packages.config"" />
  <repository path="""" />
  <repository />
</repositories>");
            fileSystem.Setup(m => m.Root).Returns(@"c:\foo\bar\baz\");
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object);

            // Act
            var paths = repository.GetRepositoryPaths().ToList();

            // Assert
            Assert.Equal(2, paths.Count);
            Assert.Equal(@"A\packages.config", paths[0]);
            Assert.Equal(@"..\..\packages.config", paths[1]);
            Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
  <repository path=""A\packages.config"" />
  <repository path=""c:\foo\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
        }

        public override void ExecuteCommand()
        {
            if (!String.IsNullOrEmpty(Arguments[0]))
            {
                var solutionFile = new FileInfo(Arguments[0]);
                if (solutionFile.Exists && solutionFile.Extension == ".sln")
                {
                    var solutionRoot = solutionFile.Directory;
                    var sharedPackagesRepository = new SharedPackageRepository(Path.Combine(solutionRoot.FullName, "packages"));
                    var solution = new Solution(solutionFile.FullName);
                    var simpleProjectObjects = solution.Projects;

                    Console.WriteLine("Processing {0} projects in solution {1}...", simpleProjectObjects.Count, solutionFile.Name);
                    foreach (var simpleProject in simpleProjectObjects)
                    {
                        var manifestDependencies = new List<ManifestDependency>();
                        var projectPath = Path.Combine(solutionFile.Directory.FullName, simpleProject.RelativePath);
                        if (File.Exists(projectPath))
                        {
                            Console.WriteLine();
                            Console.WriteLine("Processing Project: {0}", simpleProject.ProjectName);
                            var projectFileInfo = new FileInfo(projectPath);
                            var project = new Project(projectPath,new Dictionary<string, string>(),null,new ProjectCollection());
                            var assemblyOutput = project.GetPropertyValue("AssemblyName");

                            var references = project.GetItems("Reference");

                            var resolvedMappings = ResolveReferenceMappings(references, projectFileInfo);

                            if (resolvedMappings != null && resolvedMappings.Any())
                            {
                                UpdateProjectFileReferenceHintPaths(solutionRoot, project, projectPath, resolvedMappings, references);
                                var projectReferences = ParseProjectReferences(project);
                                CreateNuGetScaffolding(sharedPackagesRepository, manifestDependencies, resolvedMappings, projectFileInfo, project, projectReferences);
                            }

                            //Create nuspec regardless of whether we have added dependencies
                            if (NuSpec)
                            {
                                CreateAndOutputNuSpecFile(assemblyOutput, manifestDependencies);
                            }

                            Console.WriteLine("Project completed!");
                        }
                        else
                        {
                            Console.WriteWarning("Project: {0} was not found on disk", simpleProject.ProjectName);
                        }
                    }
                    Console.WriteLine("Complete!");
                }
                else
                {
                    Console.WriteError("Could not find solution file : {0}", solutionFile);
                }
            }
        }

        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 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"));
        }

        private RepositoryInfo GetRepositoryInfo()
        {
            // Update the path if it needs updating
            string path = _repositorySettings.RepositoryPath;

            if (_repositoryInfo == null || !_repositoryInfo.Path.Equals(path)) {
                IFileSystem fileSystem = _fileSystemProvider.GetFileSystem(path);
                ISharedPackageRepository repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem);

                _repositoryInfo = new RepositoryInfo(path, fileSystem, repository);
            }

            return _repositoryInfo;
        }

        public void CallRemovePackageWillRemoveNupkgFile(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 RegisterRepositoryAddsRelativePathToRepositoriesConfig()
        {
            // Arrange
            var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
            fileSystem.Setup(m => m.Root).Returns(@"c:\foo\");
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object);

            // Act
            repository.RegisterRepository(@"c:\foo\packages\packages.config");

            // Assert
            Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
  <repository path=""packages\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
        }

        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 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 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 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);
        }

        public void RemovingAllSolutionLevelPackageDeletesConfigFile()
        {
            // Arrange
            var fileSystem = new MockFileSystem();
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
            var solutionPackage = PackageUtility.CreatePackage("SolutionLevel", tools: new[] { "Install.ps1" });
            configFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
  <package id=""SolutionLevel"" version=""1.0"" />
</packages>");

            // Act
            repository.RemovePackage(solutionPackage);

            // Assert
            Assert.True(configFileSystem.Deleted.Contains("packages.config"));
        }

        public void AddPackageReferenceEntryAddsReferenceToPackagesConfigFile()
        {
            // Arrange
            var fileSystem = new MockFileSystem();
            var configFileSystem = new MockFileSystem();
            var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
            var solutionPackage = PackageUtility.CreatePackage("SolutionLevel", tools: new[] { "Install.ps1" });

            // Act
            repository.AddPackageReferenceEntry(solutionPackage.Id, solutionPackage.Version);
            Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
  <package id=""SolutionLevel"" version=""1.0"" />
</packages>", configFileSystem.ReadAllText("packages.config"));
        }