void CreateProjectManagerWithPackageReferenceRepository() { var sharedRepository = new FakeSharedPackageRepository(); var repository = new PackageReferenceRepository(fileSystem, "MyProject", sharedRepository); projectManager = new TestableProjectManager(repository); }
public void RemovingAndAddingPackageReferenceWithSameIdPreservesDevelopmentFlag() { // 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"" developmentDependency=""false"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: null, sourceRepository: sharedRepository.Object); var A10 = PackageUtility.CreatePackage("A"); var A20 = PackageUtility.CreatePackage("A", "2.0"); // Act referenceRepository.RemovePackage(A10); referenceRepository.AddPackage(A20); // Assert Assert.True(fileSystem.FileExists("packages.config")); AssertConfig(@"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""2.0"" developmentDependency=""false"" /> </packages>", fileSystem.ReadAllText("packages.config")); }
private IProjectManager CreateProjectManager(Project project) { // Create the project system IProjectSystem projectSystem = VsProjectSystemFactory.CreateProjectSystem(project, _fileSystemProvider); #if VS14 if (projectSystem is INuGetPackageManager) { var nugetAwareRepo = new NuGetAwareProjectPackageRepository((INuGetPackageManager)projectSystem, _sharedRepository); return new ProjectManager(this, PathResolver, projectSystem, nugetAwareRepo); } #endif PackageReferenceRepository repository = new PackageReferenceRepository(projectSystem, project.GetProperName(), _sharedRepository); // Ensure the logger is null while registering the repository FileSystem.Logger = null; Logger = null; // Ensure that this repository is registered with the shared repository if it needs to be if (repository != null) { repository.RegisterIfNecessary(); } var projectManager = new VsProjectManager(this, PathResolver, projectSystem, repository); // The package reference repository also provides constraints for packages (via the allowedVersions attribute) projectManager.ConstraintProvider = repository; return projectManager; }
void CreatePackageReferenceRepository() { helper = new PackageReferenceRepositoryHelper(); fakeFileSystem = helper.FakeProjectSystem; sourceRepository = helper.FakeSharedSourceRepository; repository = new PackageReferenceRepository(fakeFileSystem, sourceRepository); }
public void RemovePackageRemovesEntryFromPackagesConfigDeletesFileAndUnregistersRepositoryIfLastEntry() { // Arrange var sharedRepository = new Mock <ISharedPackageRepository>(); string path = null; sharedRepository.Setup(m => m.UnregisterRepository(It.IsAny <string>())) .Callback <string>(p => path = p); 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, projectName: null, sourceRepository: sharedRepository.Object); var package = PackageUtility.CreatePackage("A"); // Act referenceRepository.RemovePackage(package); // Assert Assert.False(fileSystem.FileExists("packages.config")); Assert.NotNull(path); Assert.Equal(@"C:\MockFileSystem\packages.config", path); }
public void GetPackagesLoadsPlainPackagesConfigIfProjectPackagesConfigDoesNotExist() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.cool.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" /> </packages>"); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""B"" version=""1.0"" /> <package id=""C"" version=""1.0"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: "cool", sourceRepository: repository.Object); // Act var packages = referenceRepository.GetPackages().ToList(); // Assert Assert.Equal(1, packages.Count); Assert.Same(packageA, packages[0]); Assert.True(fileSystem.FileExists("packages.cool.config")); }
public void GetPackagesReturnsPackagesFromSourceRepositoryListedInPackagesConfig() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); 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, projectName: null, sourceRepository: repository.Object); // Act var packages = referenceRepository.GetPackages().ToList(); // Assert Assert.Equal(1, packages.Count); Assert.Same(packageA, packages[0]); }
public void RemovePackagePreservesProjectConfigFile() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.cool.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" /> <package id=""B"" version=""3.0"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: "cool", sourceRepository: repository.Object); var packageB = PackageUtility.CreatePackage("B", "3.0"); // Act referenceRepository.RemovePackage(packageB); // Assert Assert.False(fileSystem.FileExists("packages.config")); Assert.True(fileSystem.FileExists("packages.cool.config")); string content = fileSystem.ReadAllText("packages.cool.config"); AssertConfig(@"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" /> </packages>", content); }
public void GetConstraintReturnsConstraintListedForPackageIdInPackagesConfig() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" allowedVersions=""[1.0, 3.0)"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: null, sourceRepository: repository.Object); // Act IVersionSpec constraint = referenceRepository.GetConstraint("A"); // Assert Assert.NotNull(constraint); Assert.True(constraint.IsMinInclusive); Assert.False(constraint.IsMaxInclusive); Assert.Equal(new SemanticVersion("1.0"), constraint.MinVersion); Assert.Equal(new SemanticVersion("3.0"), constraint.MaxVersion); }
public void RemovingAndAddingPackageReferenceWithSameIdPreservesConstraint() { // 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"" allowedVersions=""[1.0, 5.0)"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, sharedRepository.Object); var A10 = PackageUtility.CreatePackage("A"); var A20 = PackageUtility.CreatePackage("A", "2.0"); // Act referenceRepository.RemovePackage(A10); referenceRepository.AddPackage(A20); // Assert Assert.True(fileSystem.FileExists("packages.config")); AssertConfig(@"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""2.0"" allowedVersions=""[1.0, 5.0)"" /> </packages>", fileSystem.ReadAllText("packages.config")); }
public void ProjectManager_InstanceCreated_LocalRepositoryIsPackageReferenceRepository() { CreatePackageManager(); PackageReferenceRepository packageRefRepository = packageManager.ProjectManager.LocalRepository as PackageReferenceRepository; Assert.IsNotNull(packageRefRepository); }
PackageReferenceRepository CreatePackageReferenceRepository() { var sharedRepository = LocalRepository as ISharedPackageRepository; var packageRefRepository = new PackageReferenceRepository(projectSystem, projectSystem.ProjectName, sharedRepository); packageRefRepository.RegisterIfNecessary(); return(packageRefRepository); }
void CreatePackageReferenceRepository(string path) { helper = new PackageReferenceRepositoryHelper(); fakeFileSystem = helper.FakeProjectSystem; fakeFileSystem.PathToReturnFromGetFullPath = path; sourceRepository = helper.FakeSharedSourceRepository; repository = new PackageReferenceRepository(fakeFileSystem, sourceRepository); }
public TestableProjectManager(PackageReferenceRepository repository) : base( new FakePackageRepository(), new FakePackagePathResolver(), new FakeProjectSystem(), repository) { }
public IEnumerable <IPackageRepository> LoadProjectRepositories() { return(_projectRepositories.Select( f => { var projectRepository = new PackageReferenceRepository( f.FullPath, sourceRepository: this); return projectRepository; })); }
public void GetPackagesNoPackagesConfigReturnsEmptyList() { // Arrange var repository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); var referenceRepository = new PackageReferenceRepository(fileSystem, repository.Object); // Act var packages = referenceRepository.GetPackages().ToList(); // Assert Assert.AreEqual(0, packages.Count); }
public void RegisterIfNecessaryDoesNotRegistersWithSharedRepositoryIfRepositoryDoesNotContainsPackages() { // 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(); // Act var referenceRepository = new PackageReferenceRepository(fileSystem, sharedRepository.Object); referenceRepository.RegisterIfNecessary(); // Assert Assert.Null(path); }
private IProjectManager CreateProjectManager(Project project) { // Create the projet system IProjectSystem projectSystem = VsProjectSystemFactory.CreateProjectSystem(project); var repository = new PackageReferenceRepository(projectSystem, _sharedRepository); // Ensure the logger is null while registering the repository FileSystem.Logger = null; Logger = null; // Ensure that this repository is registered with the shared repository if it needs to be repository.RegisterIfNecessary(); // Create the project manager with the shared repository return(new ProjectManager(_sharedRepository, PathResolver, projectSystem, repository)); }
public void UninstallingSatellitePackageRemovesCollidingRuntimeFiles() { // Arrange // Create a runtime package and a satellite package that has a dependency on the runtime package, and uses the // local suffix convention. var runtimePackage = PackageUtility.CreatePackage( "foo", "1.0.0", content: Enumerable.Empty <string>(), assemblyReferences: new[] { @"lib\ja-jp\collision.txt" }); var satellitePackage = PackageUtility.CreatePackage( "foo.ja-jp", "1.0.0", language: "ja-jp", content: Enumerable.Empty <string>(), satelliteAssemblies: new[] { @"lib\ja-jp\collision.txt" }, dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.0.0]")) }); var packagesFolder = new MockFileSystem(@"c:\packagesFolder"); var sharedRepository = new MockSharedPackageRepository2(); var sourceRepository = new MockPackageRepository(); var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(packagesFolder), packagesFolder, sharedRepository); sourceRepository.AddPackage(runtimePackage); sourceRepository.AddPackage(satellitePackage); var projectSystem = new MockProjectSystem(); var projectLocalRepo = new PackageReferenceRepository( new MockFileSystem(@"c:\project"), "projectName", sharedRepository); var projectManager = new ProjectManager( packageManager, packageManager.PathResolver, projectSystem, projectLocalRepo); // Act Install("foo", projectManager); Install("foo.ja-jp", projectManager); Uninstall("foo.ja-jp", packageManager, projectManager); // Assert Assert.Equal(0, packagesFolder.Paths.Count); Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\ja-jp\collision.txt")); }
public void RegisterIfNecessaryDoesNotRegistersWithSharedRepositoryIfRepositoryDoesNotContainsPackages() { // 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(); // Act var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: null, sourceRepository: sharedRepository.Object); referenceRepository.RegisterIfNecessary(); // Assert Assert.Null(path); }
private void UpdatePackages(IMSBuildProjectSystem projectSystem, string repositoryPath = null, IPackageRepository sourceRepository = null) { // Resolve the repository path repositoryPath = repositoryPath ?? GetRepositoryPath(projectSystem.Root); var sharedRepositoryFileSystem = new PhysicalFileSystem(repositoryPath); var pathResolver = new DefaultPackagePathResolver(sharedRepositoryFileSystem); // Create the local and source repositories var sharedPackageRepository = new SharedPackageRepository(pathResolver, sharedRepositoryFileSystem, sharedRepositoryFileSystem); var localRepository = new PackageReferenceRepository(projectSystem, projectSystem.ProjectName, sharedPackageRepository); sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source); Console.WriteLine(LocalizedResourceManager.GetString("UpdatingProject"), projectSystem.ProjectName); UpdatePackages(localRepository, sharedRepositoryFileSystem, sharedPackageRepository, sourceRepository, localRepository, pathResolver, projectSystem); projectSystem.Save(); }
public void GetPackagesReturnsOnlyValidPackagesFromSourceRepositoryListedInPackagesConfig() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var packageC = PackageUtility.CreatePackage("C", "2.0"); repository.Object.AddPackage(packageC); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""C"" version=""2.0"" /> <package id=""B"" version=""1.0"" /> <package id=""A"" version=""1.0"" /> <package id="""" version=""1.0"" /> <package id=""G"" version="""" /> <package /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, repository.Object); // Act var packages = referenceRepository.GetPackages().ToList(); // Assert Assert.Equal(2, packages.Count); Assert.Same(packageC, packages[0]); Assert.Same(packageA, packages[1]); Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""C"" version=""2.0"" /> <package id=""B"" version=""1.0"" /> <package id=""A"" version=""1.0"" /> <package id="""" version=""1.0"" /> <package id=""G"" version="""" /> <package /> </packages>", fileSystem.ReadAllText("packages.config")); }
public void RegisterIfNecessaryRegistersWithSharedRepositoryIfRepositoryContainsPackages() { // Arrange var sharedRepository = new Mock<MockPackageRepository>().As<ISharedPackageRepository>(); string path = null; sharedRepository.Setup(m => m.RegisterRepository(It.IsAny<string>())) .Callback<string>(p => path = p); var fileSystem = new MockFileSystem(); IPackage package = PackageUtility.CreatePackage("A"); sharedRepository.Object.AddPackage(package); // Act var referenceRepository = new PackageReferenceRepository(fileSystem, sharedRepository.Object); referenceRepository.AddPackage(package); referenceRepository.RegisterIfNecessary(); // Assert Assert.Equal(@"C:\MockFileSystem\packages.config", path); }
public void GetPackagesNoPackagesConfigReturnsEmptyList() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: null, sourceRepository: repository.Object); // Act var packages = referenceRepository.GetPackages().ToList(); // Assert Assert.Equal(0, packages.Count); }
private IEnumerable <PackageDependency> GetReferences(string packagesConfigPath, IMSBuildProjectSystem project = null, string repositoryPath = null, IPackageRepository sourceRepository = null) { // Get the msbuild project project = project ?? NugetUpdateTask.GetMSBuildProject(packagesConfigPath); // Resolve the repository path repositoryPath = repositoryPath ?? GetRepositoryPath(project.Root); var sharedRepositoryFileSystem = new PhysicalFileSystem(repositoryPath); var pathResolver = new DefaultPackagePathResolver(sharedRepositoryFileSystem); // Create the local and source repositories var sharedPackageRepository = new SharedPackageRepository(pathResolver, sharedRepositoryFileSystem, sharedRepositoryFileSystem); var localRepository = new PackageReferenceRepository(project, sharedPackageRepository); sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source); IPackageConstraintProvider constraintProvider = localRepository; return(GetReferences(localRepository, sharedRepositoryFileSystem, sharedPackageRepository, sourceRepository, constraintProvider, pathResolver, project)); }
private void UpdatePackages(string packagesConfigPath, IMSBuildProjectSystem project = null, string repositoryPath = null, IPackageRepository sourceRepository = null) { // Get the msbuild project project = project ?? GetMSBuildProject(packagesConfigPath); // Resolve the repository path repositoryPath = repositoryPath ?? GetReposioryPath(project.Root); var pathResolver = new DefaultPackagePathResolver(repositoryPath); // Create the local and source repositories var localRepository = new PackageReferenceRepository(project, new SharedPackageRepository(repositoryPath)); sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source); IPackageConstraintProvider constraintProvider = localRepository; Console.WriteLine(NuGetResources.UpdatingProject, project.ProjectName); UpdatePackages(localRepository, sourceRepository, constraintProvider, pathResolver, project); project.Save(); }
public void GetPackagesWithMalformedPackagesConfigThrows() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package "); var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: null, sourceRepository: repository.Object); // Act ExceptionAssert.Throws <InvalidOperationException>(() => referenceRepository.GetPackages().ToList(), @"Error reading 'C:\MockFileSystem\packages.config'."); }
public IProjectManager CreateProjectManager(IEnumerable <string> remoteSources, string packagesPath, IProjectSystem project) { if (remoteSources == null) { throw new ArgumentNullException("remoteSources"); } if (!remoteSources.Any()) { throw new ArgumentException("Must provide at least one remote source"); } var sourceRepo = new AggregateRepository(PackageRepositoryFactory.Default, remoteSources, true); var pathResolver = new DefaultPackagePathResolver(packagesPath); var packagesConfigRepo = new PackageReferenceRepository(project, project.ProjectName, new SharedPackageRepository(packagesPath)); return(new ProjectManager(sourceRepository: sourceRepo, pathResolver: pathResolver, localRepository: packagesConfigRepo, project: project)); }
public override IProjectManager GetProjectManager(Project project) { IProjectManager projectManager; if (_projectManagers.TryGetValue(project, out projectManager)) { return projectManager; } var projectSystem = new MockVsProjectSystem(project); var localRepository = new PackageReferenceRepository( new MockFileSystem(project.GetFullPath()), project.Name, LocalRepository); projectManager = new ProjectManager( this, PathResolver, projectSystem, localRepository); _projectManagers[project] = projectManager; return projectManager; }
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 AddPackageAddsEntryToPackagesConfigWithTargetFramework() { // 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, projectName: null, sourceRepository: sharedRepository.Object); //var package = PackageUtility.CreatePackage("A"); // Act referenceRepository.AddPackage("A", new SemanticVersion("1.0"), false, new FrameworkName("Silverlight, Version=2.0")); // Assert Assert.Equal(@"C:\MockFileSystem\packages.config", path); Assert.True(fileSystem.FileExists("packages.config")); AssertConfig(@"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" targetFramework=""sl20"" /> </packages>", fileSystem.ReadAllText("packages.config")); }
public void RegisterIfNecessaryRegistersWithSharedRepositoryIfRepositoryContainsPackages() { // Arrange var sharedRepository = new Mock <MockPackageRepository>().As <ISharedPackageRepository>(); string path = null; sharedRepository.Setup(m => m.RegisterRepository(It.IsAny <string>())) .Callback <string>(p => path = p); var fileSystem = new MockFileSystem(); IPackage package = PackageUtility.CreatePackage("A"); sharedRepository.Object.AddPackage(package); // Act var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: null, sourceRepository: sharedRepository.Object); referenceRepository.AddPackage(package); referenceRepository.RegisterIfNecessary(); // Assert Assert.Equal(@"C:\MockFileSystem\packages.config", path); }
private void UpdatePackages(string packagesConfigPath, IMSBuildProjectSystem project = null, string repositoryPath = null, IPackageRepository sourceRepository = null) { // Get the msbuild project project = project ?? GetMSBuildProject(packagesConfigPath); // Resolve the repository path repositoryPath = repositoryPath ?? GetRepositoryPath(project.Root); var sharedRepositoryFileSystem = new PhysicalFileSystem(repositoryPath); var pathResolver = new DefaultPackagePathResolver(sharedRepositoryFileSystem); // Create the local and source repositories var sharedPackageRepository = new SharedPackageRepository(pathResolver, sharedRepositoryFileSystem, sharedRepositoryFileSystem); var localRepository = new PackageReferenceRepository(project, sharedPackageRepository); sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source); IPackageConstraintProvider constraintProvider = localRepository; Log(Level.Info, "Updating project {0}", project.ProjectName); UpdatePackages(localRepository, sharedRepositoryFileSystem, sharedPackageRepository, sourceRepository, constraintProvider, pathResolver, project); project.Save(); }
public void GetConstraintThrowsIfConstrainInvalid() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" allowedVersions=""[-1.3, 3)"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, projectName: null, sourceRepository: repository.Object); // Act & Assert ExceptionAssert.Throws <InvalidDataException>(() => referenceRepository.GetConstraint("A"), "Unable to parse version value '[-1.3, 3)' from '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.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 PackageReferenceRepositoryDoNotFindLatestPackageIfItDoesNotExist() { // Arrange var repository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("A", "1.5"); var packageD = PackageUtility.CreatePackage("A", "2.0-beta"); repository.Object.AddPackage(packageA); repository.Object.AddPackage(packageB); repository.Object.AddPackage(packageC); repository.Object.AddPackage(packageD); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" /> <package id=""B"" version=""2.0"" /> <package id=""A"" version=""1.5"" /> <package id=""A"" version=""2.0-beta"" /> </packages>"); ILatestPackageLookup referenceRepository = new PackageReferenceRepository( fileSystem, repository.Object); // Act SemanticVersion latestVersion; bool result = referenceRepository.TryFindLatestPackageById("C", out latestVersion); // Assert Assert.False(result); Assert.Null(latestVersion); }
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, projectName: null, sourceRepository: 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")); AssertConfig(@"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" /> </packages>", fileSystem.ReadAllText("packages.config")); }
private IProjectManager CreateProjectManager(Project project) { // Create the project system IProjectSystem projectSystem = VsProjectSystemFactory.CreateProjectSystem(project, _fileSystemProvider); var repository = new PackageReferenceRepository(projectSystem, _sharedRepository); // Ensure the logger is null while registering the repository FileSystem.Logger = null; Logger = null; // Ensure that this repository is registered with the shared repository if it needs to be repository.RegisterIfNecessary(); // The source repository of the project is an aggregate since it might need to look for all // available packages to perform updates on dependent packages var sourceRepository = CreateProjectManagerSourceRepository(); var projectManager = new ProjectManager(sourceRepository, PathResolver, projectSystem, repository); // The package reference repository also provides constraints for packages (via the allowedVersions attribute) projectManager.ConstraintProvider = repository; return projectManager; }
public void GetConstraintReturnsConstraintListedForPackageIdInPackagesConfig() { // Arrange var repository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" allowedVersions=""[1.0, 3.0)"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, repository.Object); // Act IVersionSpec constraint = referenceRepository.GetConstraint("A"); // Assert Assert.NotNull(constraint); Assert.True(constraint.IsMinInclusive); Assert.False(constraint.IsMaxInclusive); Assert.Equal(new SemanticVersion("1.0"), constraint.MinVersion); Assert.Equal(new SemanticVersion("3.0"), constraint.MaxVersion); }
public void GetPackageTargetFrameworkReturnsCorrectValue() { // Arrange var repository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" targetFramework=""winrt45"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, repository.Object); // Act var targetFramework = referenceRepository.GetPackageTargetFramework("A"); // Assert Assert.Equal(new FrameworkName(".NETCore, Version=4.5"), targetFramework); }
public void ReinstallPackagesDoesNotThrowWithNewDependencyWhenProjectFrameworkChangesIfAllowPrereleaseParameterIsFalseAndPackageVersionIsPrerelease() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v4.0")); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageReferenceRepository = new PackageReferenceRepository(projectSystem, localRepository); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, packageReferenceRepository); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackageWithDependencySets( "A", "1.2-alpha", new[] { "contentA.txt" }, dependencySets: new PackageDependencySet[] { new PackageDependencySet(new FrameworkName(".NETFramework, Version=v4.0"), new [] { new PackageDependency("B")}), new PackageDependencySet(new FrameworkName("Silverlight, Version=v5.0"), new [] { new PackageDependency("C")}) }); var packageB = PackageUtility.CreatePackage( "B", "1.0", new[] { "contentB.txt" }); var packageC = PackageUtility.CreatePackage( "C", "2.0-beta", new[] { "contentC.txt" }); sourceRepository.Add(packageA); sourceRepository.Add(packageB); sourceRepository.Add(packageC); packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); Assert.True(packageManager.LocalRepository.Exists("A")); Assert.True(projectManager.LocalRepository.Exists("A")); Assert.True(packageManager.LocalRepository.Exists("B")); Assert.True(projectManager.LocalRepository.Exists("B")); Assert.False(packageManager.LocalRepository.Exists("C")); Assert.False(projectManager.LocalRepository.Exists("C")); Assert.True(projectSystem.FileExists("contentA.txt")); Assert.True(projectSystem.FileExists("contentB.txt")); Assert.False(projectSystem.FileExists("contentC.txt")); // now change project's target framework to silverilght projectSystem.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v5.0")); // Act packageManager.ReinstallPackage(projectManager, "A", updateDependencies: true, allowPrereleaseVersions: false, logger: null); // Assert Assert.True(packageManager.LocalRepository.Exists("A")); Assert.True(projectManager.LocalRepository.Exists("A")); Assert.False(packageManager.LocalRepository.Exists("B")); Assert.False(projectManager.LocalRepository.Exists("B")); Assert.True(packageManager.LocalRepository.Exists("C")); Assert.True(projectManager.LocalRepository.Exists("C")); }
public void GetPackagesWithMalformedPackagesConfigThrows() { // Arrange var repository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package "); var referenceRepository = new PackageReferenceRepository(fileSystem, repository.Object); // Act ExceptionAssert.Throws<InvalidOperationException>(() => referenceRepository.GetPackages().ToList(), @"Error reading 'C:\MockFileSystem\packages.config'."); }
public void GetPackageReferencesReturnsFalseForNonExistentId() { // Arrange var config = @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.3.4"" /> <package id=""A"" version=""2.5-beta"" /> <package id=""B"" version=""1.0"" /> <package id=""C"" version=""2.1.4"" /> </packages>"; var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", config); var sharedRepository = new Mock<MockPackageRepository>().As<ISharedPackageRepository>(); var packageReferenceRepository = new PackageReferenceRepository(fileSystem, sharedRepository.Object); // Act SemanticVersion version; bool result = packageReferenceRepository.TryFindLatestPackageById("does-not-exist", out version); // Assert Assert.False(result); Assert.Null(version); }
public void PackageReferenceRepositoryImplementsILatestPackageLookupInterface() { // Arrange var repository = new PackageReferenceRepository(new Mock<IFileSystem>().Object, new Mock<ISharedPackageRepository>().Object); // Assert Assert.True(repository is ILatestPackageLookup); }
public void CallingCheckForMissingPackagesRaisesThePackagesMissingStatusChangedEventWithFalseValue() { // Scenario: // Project's packages.config specifies: A[1.0], B[1.2-alpha] // The solution's packages folder contains only A[1.0], B[1.2-alpha] // Arrange string tempSolutionPath = "x:\\project1"; var project = new Mock<Project>(); // setup SolutionManager var solutionManager = new Mock<ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object }); // setup file system var fileSystem = new Mock<IFileSystem>(); fileSystem.Setup(p => p.DirectoryExists(".nuget")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.exe")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.targets")).Returns(true); var fileSystemProvider = new Mock<IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem.Object); // setup VsPackageManager var projectFileSystem = new MockFileSystem(); projectFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0.0.0"" /> <package id=""B"" version=""1.2-alpha"" /> </packages>"); var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, new Mock<ISharedPackageRepository>().Object); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository); var localRepository = new MockPackageRepository(); localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0")); localRepository.AddPackage(PackageUtility.CreatePackage("B", "1.2-alpha")); var packageManager = new Mock<IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object); var packageRestore = CreateInstance( fileSystemProvider: fileSystemProvider.Object, solutionManager: solutionManager.Object, packageManagerFactory: packageManagerFactory.Object); bool? packagesMissing = null; packageRestore.PackagesMissingStatusChanged += (o, e) => { packagesMissing = e.PackagesMissing; }; // Act packageRestore.CheckForMissingPackages(); // Assert Assert.Equal(false, packagesMissing); }
public void CallingCheckForMissingPackagesRaisesThePackagesMissingStatusChangedEventWithTrueValueIfPackagesFolderIsMissing() { // Scenario: // Project's packages.config specifies: A[1.0] // The solution's packages folder doesn't contain any packages // Arrange string tempSolutionPath = "x:\\project1"; var project = new Mock<Project>(); // setup SolutionManager var solutionManager = new Mock<ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object }); // setup file system var fileSystem = new Mock<IFileSystem>(MockBehavior.Strict); var fileSystemProvider = new Mock<IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem.Object); // setup VsPackageManager var projectFileSystem = new MockFileSystem(); projectFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0.0.0"" /> </packages>"); var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, projectName: null, sourceRepository: new Mock<ISharedPackageRepository>().Object); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository); var localRepository = new MockSharedPackageRepository(); var packageManager = new Mock<IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object); var packageRestore = CreateInstance( fileSystemProvider: fileSystemProvider.Object, solutionManager: solutionManager.Object, packageManagerFactory: packageManagerFactory.Object); bool? packagesMissing = null; packageRestore.PackagesMissingStatusChanged += (o, e) => { packagesMissing = e.PackagesMissing; }; // Act packageRestore.CheckForMissingPackages(); // Assert Assert.Equal(true, packagesMissing); }
public void RemovePackageRemovesEntryFromPackagesConfigDeletesFileAndUnregistersRepositoryIfLastEntry() { // Arrange var sharedRepository = new Mock<ISharedPackageRepository>(); string path = null; sharedRepository.Setup(m => m.UnregisterRepository(It.IsAny<string>())) .Callback<string>(p => path = p); 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.RemovePackage(package); // Assert Assert.False(fileSystem.FileExists("packages.config")); Assert.NotNull(path); Assert.Equal(@"C:\MockFileSystem\packages.config", path); }
public void RemovingAndAddingPackageReferenceWithSameIdPreservesConstraint() { // 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"" allowedVersions=""[1.0, 5.0)"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, sharedRepository.Object); var A10 = PackageUtility.CreatePackage("A"); var A20 = PackageUtility.CreatePackage("A", "2.0"); // Act referenceRepository.RemovePackage(A10); referenceRepository.AddPackage(A20); // Assert Assert.True(fileSystem.FileExists("packages.config")); Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""2.0"" allowedVersions=""[1.0, 5.0)"" /> </packages>", fileSystem.ReadAllText("packages.config")); }
public void GetPackagesReturnsOnlyValidPackagesFromSourceRepositoryListedInPackagesConfig() { // Arrange var repository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var packageC = PackageUtility.CreatePackage("C", "2.0"); repository.Object.AddPackage(packageC); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""C"" version=""2.0"" /> <package id=""B"" version=""1.0"" /> <package id=""A"" version=""1.0"" /> <package id="""" version=""1.0"" /> <package id=""G"" version="""" /> <package /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, repository.Object); // Act var packages = referenceRepository.GetPackages().ToList(); // Assert Assert.Equal(2, packages.Count); Assert.Same(packageC, packages[0]); Assert.Same(packageA, packages[1]); Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""C"" version=""2.0"" /> <package id=""B"" version=""1.0"" /> <package id=""A"" version=""1.0"" /> <package id="""" version=""1.0"" /> <package id=""G"" version="""" /> <package /> </packages>", fileSystem.ReadAllText("packages.config")); }
public void ReinstallPackagesSkipReinstallingForPackagesThatDoNotExistInSource() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0")); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageReferenceRepository = new PackageReferenceRepository(projectSystem, localRepository); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, packageReferenceRepository); var installerEvents = new Mock<VsPackageInstallerEvents>(MockBehavior.Strict); int eventCount = 0; RegisterInstallerEvents(installerEvents, _ => eventCount++); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, installerEvents.Object); var packageA = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "net30\\content.txt", "silverlight40\\content4.txt" }, new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" }); var packageB = PackageUtility.CreatePackage( "B", "2.0", new[] { "net30\\contentB.txt", "silverlight40\\content4B.txt" }, new[] { "lib\\net30\\refB.dll", "lib\\silverlight40\\refslB.dll" }); localRepository.AddPackage(packageA); localRepository.AddPackage(packageB); projectManager.LocalRepository.AddPackage(packageA); projectManager.LocalRepository.AddPackage(packageB); // now change project's target framework to silverlight projectSystem.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0")); var logger = new Mock<ILogger>(); logger.Setup(s => s.Log( MessageLevel.Warning, "Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.", "B 2.0", "x:\\MockFileSystem") ).Verifiable(); logger.Setup(s => s.Log( MessageLevel.Warning, "Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.", "A 1.2-alpha", "x:\\MockFileSystem") ).Verifiable(); // Act packageManager.ReinstallPackages(projectManager, updateDependencies: false, allowPrereleaseVersions: true, logger: logger.Object); // Assert logger.Verify(); Assert.Equal(0, eventCount); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(packageManager.LocalRepository.Exists("B")); Assert.True(projectManager.LocalRepository.Exists("B")); }
public void ReinstallPackagesRestoresPackageInAllProjectsWithNewContentIfSourcePackageChanges() { // Arrange var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var localRepository = localRepositoryMock.Object; var sourceRepository = new MockPackageRepository(); var projectSystem1 = new MockProjectSystem(); var pathResolver1 = new DefaultPackagePathResolver(projectSystem1); var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository); var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1); var projectSystem2 = new MockProjectSystem(); var pathResolver2 = new DefaultPackagePathResolver(projectSystem2); var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository); var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2); var project1 = TestUtils.GetProject("Project1"); var project2 = TestUtils.GetProject("Project2"); var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManager(projects: new[] { project1, project2 }), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem2, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); packageManager.RegisterProjectManager(project1, projectManager1); packageManager.RegisterProjectManager(project2, projectManager2); var packageA = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "content.txt" }, new[] { "lib\\ref.dll" }); var packageA2 = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "foo.txt" }, new[] { "lib\\bar.dll" }); var packageB = PackageUtility.CreatePackage( "B", "2.0", new[] { "hello.txt" }, new[] { "lib\\comma.dll" }); var packageB2 = PackageUtility.CreatePackage( "B", "2.0", new[] { "world.txt" }, new[] { "lib\\dude.dll" }); sourceRepository.Add(packageA); sourceRepository.Add(packageB); // install package A -> project 1 // and package B -> project 2 packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectSystem1.FileExists("content.txt")); Assert.True(projectSystem1.ReferenceExists("ref.dll")); Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectSystem2.FileExists("hello.txt")); Assert.True(projectSystem2.ReferenceExists("comma.dll")); // now change the package A and B to different packages sourceRepository.RemovePackage(packageA); sourceRepository.RemovePackage(packageB); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageB2); localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version)); localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version)); // Act packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance, eventListener: NullPackageOperationEventListener.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.False(projectSystem1.FileExists("content.txt")); Assert.True(projectSystem1.FileExists("foo.txt")); Assert.False(projectSystem1.ReferenceExists("ref.dll")); Assert.True(projectSystem1.ReferenceExists("bar.dll")); Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.False(projectSystem2.FileExists("hello.txt")); Assert.True(projectSystem2.FileExists("world.txt")); Assert.False(projectSystem2.ReferenceExists("comma.dll")); Assert.True(projectSystem2.ReferenceExists("dude.dll")); }
public void ReinstallPackagesRestoresAllPackagesInAProjectWithNewContentIfProjectFrameworkChanges() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0")); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageReferenceRepository = new PackageReferenceRepository(projectSystem, localRepository); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, packageReferenceRepository); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "net30\\content.txt", "silverlight40\\content4.txt" }, new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" }); var packageB = PackageUtility.CreatePackage( "B", "2.0", new[] { "net30\\contentB.txt", "silverlight40\\content4B.txt" }, new[] { "lib\\net30\\refB.dll", "lib\\silverlight40\\refslB.dll" }); sourceRepository.Add(packageA); sourceRepository.Add(packageB); packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); packageManager.InstallPackage(projectManager, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectSystem.FileExists("content.txt")); Assert.False(projectSystem.FileExists("content4.txt")); Assert.True(projectSystem.ReferenceExists("ref.dll")); Assert.False(projectSystem.ReferenceExists("refsl.dll")); Assert.True(packageManager.LocalRepository.Exists("B")); Assert.True(projectManager.LocalRepository.Exists("B")); Assert.True(projectSystem.FileExists("contentB.txt")); Assert.False(projectSystem.FileExists("content4B.txt")); Assert.True(projectSystem.ReferenceExists("refB.dll")); Assert.False(projectSystem.ReferenceExists("refslB.dll")); // now change project's target framework to silverlight projectSystem.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0")); // Act packageManager.ReinstallPackages(projectManager, updateDependencies: true, allowPrereleaseVersions: false, logger: null); // Assert Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.False(projectSystem.FileExists("content.txt")); Assert.True(projectSystem.FileExists("content4.txt")); Assert.False(projectSystem.ReferenceExists("ref.dll")); Assert.True(projectSystem.ReferenceExists("refsl.dll")); Assert.True(packageManager.LocalRepository.Exists("B")); Assert.True(projectManager.LocalRepository.Exists("B")); Assert.False(projectSystem.FileExists("contentB.txt")); Assert.True(projectSystem.FileExists("content4B.txt")); Assert.False(projectSystem.ReferenceExists("refB.dll")); Assert.True(projectSystem.ReferenceExists("refslB.dll")); }
public void GetPackageTargetFrameworkReturnsNullIfPackageIdIsNotPresent() { // Arrange var repository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); 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, repository.Object); // Act var targetFramework = referenceRepository.GetPackageTargetFramework("B"); // Assert Assert.Null(targetFramework); }
public void ReinstallPackagesSkipRestallingForOneProjectButProceedWithTheOther() { // Arrange var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var localRepository = localRepositoryMock.Object; var sourceRepository = new MockPackageRepository(); var projectSystem1 = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0")); var pathResolver1 = new DefaultPackagePathResolver(projectSystem1); var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository); var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1); var projectSystem2 = new MockProjectSystem(new FrameworkName(".NETCore, Version=v4.5")); var pathResolver2 = new DefaultPackagePathResolver(projectSystem2); var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository); var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2); var project1 = TestUtils.GetProject("Project1"); var project2 = TestUtils.GetProject("Project2"); var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManager(projects: new[] { project1, project2 }), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem2, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); packageManager.RegisterProjectManager(project1, projectManager1); packageManager.RegisterProjectManager(project2, projectManager2); var packageA = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "net30\\content.txt", "silverlight40\\content4.txt" }, new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" }); var packageB = PackageUtility.CreatePackage( "B", "2.0", new[] { "winrt45\\hello.txt", "sl4-wp71\\world.txt" }, new[] { "lib\\winrt45\\comma.dll", "lib\\sl4-wp71\\dude.dll" }); sourceRepository.Add(packageA); localRepository.AddPackage(packageA); localRepository.AddPackage(packageB); // install package A -> project 1 // and package B -> project 2 packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); // now change project's target framework to silverlight projectSystem1.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0")); projectSystem2.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0, Profile=WindowsPhone71")); localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version)); localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version)); var logger = new Mock<ILogger>(); logger.Setup(s => s.Log( MessageLevel.Warning, "Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.", "B 2.0", "Project2") ).Verifiable(); // Act packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: logger.Object, eventListener: NullPackageOperationEventListener.Instance); // Assert logger.Verify(); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.False(projectSystem1.FileExists("content.txt")); Assert.True(projectSystem1.FileExists("content4.txt")); Assert.False(projectSystem1.ReferenceExists("ref.dll")); Assert.True(projectSystem1.ReferenceExists("refsl.dll")); Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectSystem2.FileExists("hello.txt")); Assert.False(projectSystem2.FileExists("world.txt")); Assert.True(projectSystem2.ReferenceExists("comma.dll")); Assert.False(projectSystem2.ReferenceExists("dude.dll")); }
public void GetConstraintThrowsIfConstrainInvalid() { // Arrange var repository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A"); repository.Object.AddPackage(packageA); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" allowedVersions=""[-1.3, 3)"" /> </packages>"); var referenceRepository = new PackageReferenceRepository(fileSystem, repository.Object); // Act & Assert ExceptionAssert.Throws<InvalidDataException>(() => referenceRepository.GetConstraint("A"), "Unable to parse version value '[-1.3, 3)' from 'packages.config'."); }
public void CallingRestoreMissingPackagesMethodInstallMissingPackages() { // Scenario: // Project's packages.config specifies: A[1.0] // The solution's packages folder contains only A[1.0], B[1.2-alpha], C[2.0-RC1] // Call RestoreMissingPackages() will install B[1.2-alpha] and C[2.0-RC1] into the solution // Arrange string tempSolutionPath = "x:\\project1"; var project = new Mock<Project>(); // setup SolutionManager var solutionManager = new Mock<ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object }); // setup file system var fileSystem = new Mock<IFileSystem>(); fileSystem.Setup(p => p.DirectoryExists(".nuget")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.exe")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.targets")).Returns(true); var fileSystemProvider = new Mock<IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem.Object); // setup VsPackageManager string tempFile = @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0.0.0"" /> <package id=""B"" version=""1.2-alpha"" /> <package id=""C"" version=""2.0-RC1"" /> </packages>"; var projectFileSystem = new MockFileSystem(); projectFileSystem.AddFile("packages.config", tempFile); var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, new Mock<ISharedPackageRepository>().Object); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository); var localRepository = new MockPackageRepository(); localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0")); var packageManager = new Mock<IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object); var packageRestore = CreateInstance( fileSystemProvider: fileSystemProvider.Object, solutionManager: solutionManager.Object, packageManagerFactory: packageManagerFactory.Object); Exception exception = null; var manualEvent = new ManualResetEventSlim(); // Act packageRestore.RestoreMissingPackages().ContinueWith( task => { if (task.IsFaulted) { exception = task.Exception; manualEvent.Set(); return; } try { // Assert packageManager.Verify(p => p.InstallPackage("A", new SemanticVersion("1.0.0.0"), true, true), Times.Never()); packageManager.Verify(p => p.InstallPackage("B", new SemanticVersion("1.2-alpha"), true, true), Times.Once()); packageManager.Verify(p => p.InstallPackage("C", new SemanticVersion("2.0-RC1"), true, true), Times.Once()); } catch (Exception testException) { exception = testException; } finally { manualEvent.Set(); } }); manualEvent.Wait(); Assert.Null(exception); }
public void PackageReferenceRepositoryDoNotFindLatestPackageIfItDoesNotExist() { // Arrange var repository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("A", "1.5"); var packageD = PackageUtility.CreatePackage("A", "2.0-beta"); repository.Object.AddPackage(packageA); repository.Object.AddPackage(packageB); repository.Object.AddPackage(packageC); repository.Object.AddPackage(packageD); var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" /> <package id=""B"" version=""2.0"" /> <package id=""A"" version=""1.5"" /> <package id=""A"" version=""2.0-beta"" /> </packages>"); ILatestPackageLookup referenceRepository = new PackageReferenceRepository( fileSystem, repository.Object); // Act SemanticVersion latestVersion; bool result = referenceRepository.TryFindLatestPackageById("C", out latestVersion); // Assert Assert.False(result); Assert.Null(latestVersion); }
private void UpdatePackages(IMSBuildProjectSystem project, string repositoryPath = null, IPackageRepository sourceRepository = null) { // Resolve the repository path repositoryPath = repositoryPath ?? GetRepositoryPath(project.Root); var sharedRepositoryFileSystem = new PhysicalFileSystem(repositoryPath); var pathResolver = new DefaultPackagePathResolver(sharedRepositoryFileSystem); // Create the local and source repositories var sharedPackageRepository = new SharedPackageRepository(pathResolver, sharedRepositoryFileSystem, sharedRepositoryFileSystem); var localRepository = new PackageReferenceRepository(project, project.ProjectName, sharedPackageRepository); sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source); Console.WriteLine(LocalizedResourceManager.GetString("UpdatingProject"), project.ProjectName); UpdatePackages(localRepository, sharedRepositoryFileSystem, sharedPackageRepository, sourceRepository, localRepository, pathResolver, project); project.Save(); }
public void GetPackageReferencesFindTheOnlyVersionAsLatestVersion() { // Arrange var config = @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.3.4"" /> <package id=""A"" version=""2.5-beta"" /> <package id=""B"" version=""1.0"" /> <package id=""C"" version=""2.1.4"" /> </packages>"; var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", config); var sharedRepository = new Mock<MockPackageRepository>().As<ISharedPackageRepository>(); var packageReferenceRepository = new PackageReferenceRepository(fileSystem, sharedRepository.Object); // Act SemanticVersion version; bool result = packageReferenceRepository.TryFindLatestPackageById("B", out version); // Assert Assert.True(result); Assert.Equal(new SemanticVersion("1.0"), version); }