public void InstallPackageWithOperationsExecuteAllOperations()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, dependencies: new PackageDependency[] { new PackageDependency("bar") });
sourceRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" });
sourceRepository.AddPackage(package2);
var package3 = PackageUtility.CreatePackage("awesome", "1.0", new[] { "candy" });
localRepository.AddPackage(package3);
var operations = new PackageOperation[] {
new PackageOperation(package, PackageAction.Install),
new PackageOperation(package2, PackageAction.Install),
new PackageOperation(package3, PackageAction.Uninstall)
};
// Act
packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, logger: NullLogger.Instance);
// Assert
Assert.IsTrue(packageManager.LocalRepository.Exists(package));
Assert.IsTrue(packageManager.LocalRepository.Exists(package2));
Assert.IsTrue(!packageManager.LocalRepository.Exists(package3));
Assert.IsTrue(projectManager.LocalRepository.Exists(package));
Assert.IsTrue(projectManager.LocalRepository.Exists(package2));
}
public void ReverseDependencyWalkerUsersVersionAndIdToDetermineVisited()
{
// Arrange
// A 1.0 -> B 1.0
IPackage packageA1 = PackageUtility.CreatePackage("A",
"1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "[1.0]")
});
// A 2.0 -> B 2.0
IPackage packageA2 = PackageUtility.CreatePackage("A",
"2.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "[2.0]")
});
IPackage packageB1 = PackageUtility.CreatePackage("B", "1.0");
IPackage packageB2 = PackageUtility.CreatePackage("B", "2.0");
var mockRepository = new MockPackageRepository();
mockRepository.AddPackage(packageA1);
mockRepository.AddPackage(packageA2);
mockRepository.AddPackage(packageB1);
mockRepository.AddPackage(packageB2);
// Act
IDependentsResolver lookup = new DependentsWalker(mockRepository);
// Assert
Assert.Equal(0, lookup.GetDependents(packageA1).Count());
Assert.Equal(0, lookup.GetDependents(packageA2).Count());
Assert.Equal(1, lookup.GetDependents(packageB1).Count());
Assert.Equal(1, lookup.GetDependents(packageB2).Count());
}
private static MockPackageRepository CreateMockRepository()
{
var mockRepo = new MockPackageRepository();
mockRepo.AddPackage(PackageUtility.CreatePackage("Test1", isLatest: true, assemblyReferences: new List<string> { "Assembly11.dll", "Assembly12.dll" }, dependencies: new List<PackageDependency> { new PackageDependency("Test2") }));
mockRepo.AddPackage(PackageUtility.CreatePackage("Test2", isLatest: true, assemblyReferences: new List<string> { "Assembly21.dll", "Assembly22.dll" }, dependencies: new List<PackageDependency> { new PackageDependency("Test1") }));
return mockRepo;
}
public void CanExecuteReturnsCorrectResult()
{
// Local repository contains Package A and Package B
// We test the CanExecute() method on Package A and Package C
// Arrange
var repository = new MockPackageRepository();
var packageA = PackageUtility.CreatePackage("A", "1.0");
repository.AddPackage(packageA);
var packageB = PackageUtility.CreatePackage("B", "2.0");
repository.AddPackage(packageB);
var packageC = PackageUtility.CreatePackage("C", "2.0");
var projectManager = new Mock<IProjectManager>();
projectManager.Setup(p => p.IsInstalled(It.IsAny<IPackage>())).Returns<IPackage>(p => repository.Exists(p));
var provider = CreateInstalledProvider(null, projectManager.Object);
var extensionA = new PackageItem(provider, packageA, null);
var extensionC = new PackageItem(provider, packageC, null);
// Act
bool canExecuteA = provider.CanExecute(extensionA);
bool canExecuteC = provider.CanExecute(extensionC);
// Assert
Assert.IsTrue(canExecuteA);
Assert.IsFalse(canExecuteC);
}
public static MockPackageRepository CreateMockRepository()
{
var mockRepo = new MockPackageRepository();
mockRepo.AddPackage(PackageUtility.CreatePackage(PackageInRepository, isLatest: true, assemblyReferences: new List<string> { AssemblyFilenameInPackageRepository, "Assembly12.dll" }, dependencies: new List<PackageDependency>()));
mockRepo.AddPackage(PackageUtility.CreatePackage("Test2", isLatest: true, assemblyReferences: new List<string> { AnotherAssemblyInPackageRepository, "Assembly22.dll" }, dependencies: new List<PackageDependency> { new PackageDependency(PackageInRepository) }));
return mockRepo;
}
public void GetPackagesReturnsUpdatesWhenThereAreMultipleVersionsOfTheSamePackageId()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockServiceBasePackageRepository();
UpdatesTreeNode node = CreateUpdatesTreeNode(localRepository, sourceRepository, includePrerelease: false);
localRepository.AddPackage(PackageUtility.CreatePackage("A", "9.0-rtm"));
localRepository.AddPackage(PackageUtility.CreatePackage("B", "1.0"));
localRepository.AddPackage(PackageUtility.CreatePackage("A", "9.0"));
localRepository.AddPackage(PackageUtility.CreatePackage("A", "10.0"));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "9.5"));
sourceRepository.AddPackage(PackageUtility.CreatePackage("B", "4.0-beta"));
sourceRepository.AddPackage(PackageUtility.CreatePackage("C", "1.2.3.4-alpha"));
// Act
var packages = node.GetPackages(searchTerm: null, allowPrereleaseVersions: true).ToList();
// Assert
Assert.Equal(2, packages.Count);
AssertPackage(packages[0], "A", "9.5");
AssertPackage(packages[1], "B", "4.0-beta");
}
public void InstallPackageSetOperationToInstall3()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
sourceRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" });
sourceRepository.AddPackage(package2);
// Act
packageManager.InstallPackage(
projectManager,
package2,
new PackageOperation[] {
new PackageOperation(package, PackageAction.Install),
new PackageOperation(package2, PackageAction.Install),
},
ignoreDependencies: false,
allowPrereleaseVersions: false,
logger: NullLogger.Instance);
// Assert
Assert.Equal("Install", sourceRepository.LastOperation);
Assert.Equal("bar", sourceRepository.LastMainPackageId);
Assert.Equal("2.0", sourceRepository.LastMainPackageVersion);
}
public void InstallMetadataPackageWithReadMeInstallsIntoProjectAndPackageManager()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
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.0", dependencies: new[] { new PackageDependency("B") });
var mockPackageA = Mock.Get(packageA);
mockPackageA.Setup(m => m.GetFiles()).Returns(PackageUtility.CreateFiles(new[] { "readme.txt" }));
var packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "hello.txt" });
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
// Act
packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance);
// Assert
Assert.True(packageManager.LocalRepository.Exists(packageA));
Assert.True(projectManager.LocalRepository.Exists(packageA));
Assert.True(packageManager.LocalRepository.Exists(packageB));
Assert.True(projectManager.LocalRepository.Exists(packageB));
}
public void GetUpdatesReturnAllPackageVersionsWhenFlagIsSpecified()
{
// Arrange
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0", new string[] { "hello" }));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "2.0", new string[] { "hello" }));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "3.0", new string[] { "hello" }));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "3.0-alpha", new string[] { "hello" }));
var packages = new IPackage[]
{
PackageUtility.CreatePackage("A", "1.5")
};
// Act
var foundPackages = PackageRepositoryExtensions.GetUpdates(sourceRepository, packages, includePrerelease: true, includeAllVersions: true).ToList();
// Assert
Assert.Equal(3, foundPackages.Count);
Assert.Equal("A", foundPackages[0].Id);
Assert.Equal(new SemanticVersion("2.0"), foundPackages[0].Version);
Assert.Equal("A", foundPackages[1].Id);
Assert.Equal(new SemanticVersion("3.0"), foundPackages[1].Version);
Assert.Equal("A", foundPackages[2].Id);
Assert.Equal(new SemanticVersion("3.0-alpha"), foundPackages[2].Version);
}
public void AfterPackageWalkMetaPackageIsClassifiedTheSameAsDependencies()
{
// Arrange
var mockRepository = new MockPackageRepository();
var walker = new TestWalker(mockRepository);
IPackage metaPackage = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B"),
new PackageDependency("C")
});
IPackage projectPackageA = PackageUtility.CreatePackage("B", "1.0", content: new[] { "contentB" });
IPackage projectPackageB = PackageUtility.CreatePackage("C", "1.0", content: new[] { "contentC" });
mockRepository.AddPackage(projectPackageA);
mockRepository.AddPackage(projectPackageB);
Assert.AreEqual(PackageTargets.None, walker.GetPackageInfo(metaPackage).Target);
// Act
walker.Walk(metaPackage);
// Assert
Assert.AreEqual(PackageTargets.Project, walker.GetPackageInfo(metaPackage).Target);
}
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager = new Mock<IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(localRepository);
var packageManager = new Mock<IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
var provider = CreateOnlineProvider(packageManager.Object, projectManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock<IVsPackageManager> mockPackageManager = Mock.Get<IVsPackageManager>(activePackageManager);
ManualResetEvent manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate {
// Assert
mockPackageManager.Verify(p => p.InstallPackage(projectManager.Object, packageB, It.IsAny<IEnumerable<PackageOperation>>(), false, provider), Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB, null);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.WaitOne();
}
public void InstallPackageUsesProjectTargetFramework()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5"));
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, new MockPackageRepository());
var packageManager = new VsPackageManager(
TestUtils.GetSolutionManager(),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem,
localRepository,
new Mock<IRecentPackageRepository>().Object,
new Mock<VsPackageInstallerEvents>().Object);
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(
new FrameworkName(".NETFramework, Version=4.5"),
new [] { new PackageDependency("B") }),
new PackageDependencySet(
new FrameworkName(".NETFramework, Version=4.0"),
new [] { new PackageDependency("C") })
};
var package = PackageUtility.CreatePackageWithDependencySets(
"foo",
"1.0",
new[] { "hello" },
dependencySets: dependencySets);
var packageB = PackageUtility.CreatePackage("B", "2.0", new[] { "good morning" });
var packageC = PackageUtility.CreatePackage("C", "2.0", new[] { "good morning" });
sourceRepository.AddPackage(package);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
// Act
packageManager.InstallPackage(projectManager, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance);
// Assert
Assert.True(packageManager.LocalRepository.Exists(package));
Assert.True(packageManager.LocalRepository.Exists(packageB));
Assert.False(packageManager.LocalRepository.Exists(packageC));
Assert.True(projectManager.LocalRepository.Exists(package));
Assert.True(projectManager.LocalRepository.Exists(packageB));
}
public void AddPackageReferencePreferPackagesProjectNameConfigOverNormalConfig()
{
// Arrange
var sourceRepository = new MockPackageRepository();
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
assemblyReferences: new[] { "lib\\a.dll" });
sourceRepository.AddPackage(packageA);
IPackage packageB = PackageUtility.CreatePackage(
"B",
"1.0",
assemblyReferences: new[] { "lib\\b.dll" });
sourceRepository.AddPackage(packageB);
IPackage packageC = PackageUtility.CreatePackage(
"C",
"1.0",
assemblyReferences: new[] { "lib\\c.dll" });
sourceRepository.AddPackage(packageC);
var projectSystem = new MockProjectSystem(
new FrameworkName(".NETFramework, Version=4.5"));
projectSystem.ProjectName = "CoolProject";
projectSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""B"" version=""1.0"" />
</packages>");
projectSystem.AddFile("packages.CoolProject.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""C"" version=""1.0"" />
</packages>");
var localRepository = new MockPackageRepository();
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
localRepository.AddPackage(packageC);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.True(projectManager.LocalRepository.Exists("C"));
Assert.True(projectManager.Project.FileExists("packages.CoolProject.config"));
Assert.True(projectManager.Project.FileExists("packages.config"));
}
public void GetPackagesReturnPrereleasePackages()
{
// Arrange
MockPackageRepository repository = new MockPackageRepository();
int numberOfPackages = 3;
IPackage[] packages = new IPackage[numberOfPackages];
for (int i = 0; i < numberOfPackages; i++)
{
packages[i] = PackageUtility.CreatePackage("A" + i, "1.0-alpha");
repository.AddPackage(packages[i]);
}
SimpleTreeNode node = CreateSimpleTreeNode(repository);
// Act
var producedPackages = node.GetPackages(allowPrereleaseVersions: true).ToList();
// Assert
Assert.Equal(packages.Length, producedPackages.Count);
for (int i = 0; i < numberOfPackages; i++)
{
Assert.Same(packages[i], producedPackages[i]);
}
}
public void AddPackageReferenceAppliesPackageReferencesCorrectly2()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
assemblyReferences: new[] { "lib\\net35\\a.dll", "lib\\net35\\b.dll" });
sourceRepository.AddPackage(packageA);
Mock<IPackage> mockPackageA = Mock.Get<IPackage>(packageA);
mockPackageA.Setup(m => m.PackageAssemblyReferences).Returns(
new PackageReferenceSet[] {
new PackageReferenceSet(VersionUtility.ParseFrameworkName("net40"), new [] { "a.dll" }),
new PackageReferenceSet(VersionUtility.ParseFrameworkName("net45"), new [] { "b.dll" })
}
);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.False(projectSystem.ReferenceExists("a.dll"));
Assert.True(projectSystem.ReferenceExists("b.dll"));
}
public void InstallPackageRunsInitAndInstallScripts()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectRepository = new MockProjectPackageRepository(localRepository);
var fileSystem = new MockFileSystem();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(new MockProjectSystem());
var project = TestUtils.GetProject("Foo");
var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository);
var scriptExecutor = new Mock<IScriptExecutor>();
var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IRecentPackageRepository>().Object,
new Mock<VsPackageInstallerEvents>().Object) { CallBase = true };
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false, false)).Returns(packageManager.Object);
packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager);
var package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, tools: new[] { "init.ps1", "install.ps1" });
sourceRepository.AddPackage(package);
var installer = new VsPackageInstaller(packageManagerFactory.Object, scriptExecutor.Object, new Mock<IPackageRepositoryFactory>().Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object);
// Act
installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false);
// Assert
scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Init, It.IsAny<IPackage>(), It.IsAny<Project>(), It.IsAny<ILogger>()), Times.Once());
scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Install, It.IsAny<IPackage>(), It.IsAny<Project>(), It.IsAny<ILogger>()), Times.Once());
}
public void AddPackageWithXdtTransformFile()
{
// Arrange
var mockProjectSystem = new MockProjectSystem();
var mockRepository = new MockPackageRepository();
mockProjectSystem.AddFile("web.config",
@"<configuration>
<system.web>
<compilation debug=""true"" />
</system.web>
</configuration>
".AsStream());
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(new MockProjectSystem()), mockProjectSystem, new MockPackageRepository());
var package = new Mock<IPackage>();
package.Setup(m => m.Id).Returns("A");
package.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
package.Setup(m => m.Listed).Returns(true);
var file = new Mock<IPackageFile>();
file.Setup(m => m.Path).Returns(@"content\web.config.install.xdt");
file.Setup(m => m.EffectivePath).Returns("web.config.install.xdt");
file.Setup(m => m.GetStream()).Returns(() =>
@"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform"">
<system.web>
<compilation xdt:Locator=""Condition('@debug=true')"" debug=""false"" xdt:Transform=""Replace"" />
</system.web>
</configuration>".AsStream());
var file2 = new Mock<IPackageFile>();
file2.Setup(m => m.Path).Returns(@"content\web.config.uninstall.xdt");
file2.Setup(m => m.EffectivePath).Returns("web.config.uninstall.xdt");
file2.Setup(m => m.GetStream()).Returns(() =>
@"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform"">
<system.web>
<compilation xdt:Locator=""Match(debug)"" debug=""false"" xdt:Transform=""Remove"" />
</system.web>
</configuration>".AsStream());
package.Setup(m => m.GetFiles()).Returns(new[] { file.Object, file2.Object });
mockRepository.AddPackage(package.Object);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(mockProjectSystem.FileExists("web.config.install.xdt"));
Assert.False(mockProjectSystem.FileExists("web.config.uninstall.xdt"));
Assert.True(mockProjectSystem.FileExists("web.config"));
Assert.Equal(
@"<configuration>
<system.web>
<compilation debug=""false""/>
</system.web>
</configuration>
", mockProjectSystem.OpenFile("web.config").ReadToEnd());
}
public void ExternalPackagesThatDepdendOnProjectLevelPackagesThrows()
{
// Arrange
var mockRepository = new MockPackageRepository();
var walker = new TestWalker(mockRepository);
IPackage solutionPackage = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B")
}, tools: new[] { "install.ps1" });
IPackage projectPackageA = PackageUtility.CreatePackage("B", "1.0", content: new[] { "contentB" });
mockRepository.AddPackage(projectPackageA);
mockRepository.AddPackage(solutionPackage);
// Act && Assert
ExceptionAssert.Throws<InvalidOperationException>(() => walker.Walk(solutionPackage), "External packages cannot depend on packages that target projects.");
}
public void CanDetectMissingVersionAndUpdateToValid()
{
var fileSystem = new MockFileSystem(@"d:\");
fileSystem.AddFile(@"d:\test\packages.config",
"<packages>" +
"<package id=\"Test\" version=\"1.0.0.0\" />" +
"<package id=\"Other\" version=\"1.0.0.0\" />" +
"</packages>");
var repository = new MockPackageRepository("http://test.com");
repository.AddPackage(PackageUtility.CreatePackage("Test", "2.0.0.0"));
repository.AddPackage(PackageUtility.CreatePackage("Other", "1.0.0.0"));
var command = new FixReferences(fileSystem, repository, new Console()) {Directory = @"d:\test"};
command.Execute();
var packageReferences = new PackageReferenceFile(fileSystem, @"d:\test\packages.config").GetPackageReferences().ToList();
Assert.AreEqual("2.0.0.0", packageReferences.First(p => p.Id == "Test").Version.Version.ToString());
Assert.AreEqual("1.0.0.0", packageReferences.First(p => p.Id == "Other").Version.Version.ToString());
}
public void GetPackagesReturnsCorrectPackages3()
{
// Arrange
MockPackageRepository localRepository = new MockPackageRepository();
MockPackageRepository sourceRepository = new MockPackageRepository();
UpdatesTreeNode node = CreateSimpleTreeNode(localRepository, sourceRepository);
localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.5"));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "0.9"));
// Act
var packages = node.GetPackages().ToList();
// Assert
Assert.AreEqual(1, packages.Count);
AssertPackage(packages[0], "A", "1.5");
}
public void GetPackagesIngoresLowerVersions()
{
// Arrange
MockPackageRepository localRepository = new MockPackageRepository();
MockPackageRepository sourceRepository = new MockPackageRepository();
UpdatesTreeNode node = CreateUpdatesTreeNode(localRepository, sourceRepository, includePrerelease: false);
localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.5"));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "0.9"));
// Act
var packages = node.GetPackages(searchTerm: null, allowPrereleaseVersions: true).ToList();
// Assert
Assert.Equal(1, packages.Count);
AssertPackage(packages[0], "A", "1.5");
}
public void GetPackagesReturnsUpdatesIgnoreConstraintIfConstraintIsNull()
{
// Arrange
var localRepository = new Mock<IPackageRepository>();
localRepository.Setup(l => l.GetPackages()).Returns(new IPackage[] { PackageUtility.CreatePackage("A", "1.0") }.AsQueryable());
Mock<IPackageConstraintProvider> constraintProvider = localRepository.As<IPackageConstraintProvider>();
constraintProvider.Setup(c => c.GetConstraint("A")).Returns((IVersionSpec)null);
MockPackageRepository sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.5"));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "2.5"));
UpdatesTreeNode node = CreateUpdatesTreeNode(localRepository.Object, sourceRepository, includePrerelease: false);
// Act
var packages = node.GetPackages(searchTerm: null, allowPrereleaseVersions: true).ToList();
// Assert
Assert.Equal(1, packages.Count);
AssertPackage(packages[0], "A", "2.5");
}
public static void GetPackagesToBeReinstalledWhenProjectKindIsNull()
{
// Arrange
Mock<Project> mockProject = new Mock<Project>();
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(PackageUtility.CreatePackage("A"));
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, localRepository);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public void CanExecuteReturnsCorrectResult()
{
// Local repository contains Package A 1.0 and Package B
// Source repository contains Package A 2.0 and Package C
var packageA1 = PackageUtility.CreatePackage("A", "1.0");
var packageA2 = PackageUtility.CreatePackage("A", "2.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
// Arrange
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA1);
localRepository.AddPackage(packageB);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageC);
var projectManager = new Mock<IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(localRepository);
var packageManager = new Mock<IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
var provider = CreateUpdatesProvider(packageManager.Object, projectManager.Object);
var extensionA = new PackageItem(provider, packageA2, null);
var extensionC = new PackageItem(provider, packageC, null);
// Act
bool canExecuteA = provider.CanExecute(extensionA);
bool canExecuteC = provider.CanExecute(extensionC);
// Assert
Assert.IsTrue(canExecuteA);
Assert.IsFalse(canExecuteC);
}
public void CanExecuteReturnsCorrectResult()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager = new Mock<IProjectManager>();
projectManager.Setup(p => p.IsInstalled(It.IsAny<IPackage>())).Returns<IPackage>(p => localRepository.Exists(p));
var packageManager = new Mock<IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
var provider = CreateOnlineProvider(packageManager.Object, projectManager.Object);
var extensionA = new PackageItem(provider, packageA, null);
var extensionB = new PackageItem(provider, packageB, null);
var extensionC = new PackageItem(provider, packageC, null);
// Act
bool canExecuteA = provider.CanExecute(extensionA);
bool canExecuteB = provider.CanExecute(extensionB);
bool canExecuteC = provider.CanExecute(extensionC);
// Assert
Assert.IsTrue(canExecuteC);
Assert.IsTrue(canExecuteB);
Assert.IsFalse(canExecuteA);
}
public IPackageRepositoryFactory CreatePackageRepositoryFactory()
{
//Default Repository
MockPackageRepository defaultPackageRepository = new MockPackageRepository();
var packageA = PackageUtility.CreatePackage("DefaultUrlUsed", "1.0");
defaultPackageRepository.AddPackage(packageA);
var packageC = PackageUtility.CreatePackage("SearchPackage", "1.0");
defaultPackageRepository.AddPackage(packageC);
var packageD = PackageUtility.CreatePackage("AnotherTerm", "1.0");
defaultPackageRepository.AddPackage(packageD);
//Nondefault Repository (Custom URL)
MockPackageRepository nondefaultPackageRepository = new MockPackageRepository();
var packageB = PackageUtility.CreatePackage("CustomUrlUsed", "1.0");
nondefaultPackageRepository.AddPackage(packageB);
// Repo with multiple versions
var multiVersionRepo = new MockPackageRepository();
multiVersionRepo.AddPackage(PackageUtility.CreatePackage("NHibernate", "1.0"));
multiVersionRepo.AddPackage(PackageUtility.CreatePackage("NHibernate", "1.1"));
multiVersionRepo.AddPackage(PackageUtility.CreatePackage("NHibernate", "1.2"));
multiVersionRepo.AddPackage(PackageUtility.CreatePackage("jQuery", "1.44"));
multiVersionRepo.AddPackage(PackageUtility.CreatePackage("jQuery", "1.50"));
//Setup Factory
var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>();
packageRepositoryFactory.Setup(p => p.CreateRepository(It.IsAny<PackageSource>())).Returns<PackageSource>(s => {
switch (s.Source) {
case NonDefaultRepoUrl1: return nondefaultPackageRepository;
case NonDefaultRepoUrl2: return multiVersionRepo;
default: return defaultPackageRepository;
}
});
//Return the Factory
return packageRepositoryFactory.Object;
}
public void CreatePackageMananagerForPackageRestoreUsesPackageRestoreRepositoryWithAggregateSecondary()
{
// Arrange
var mockRepositoryFactory = new Mock<IPackageRepositoryFactory>();
var mockSourceProvider = new Mock<IVsPackageSourceProvider>();
var mockFileSystemProvider = new Mock<IFileSystemProvider>();
var mockRepository1 = new MockPackageRepository("Source1");
var mockRepository2 = new MockPackageRepository("Source2");
var mockRepository3 = new MockPackageRepository("Source3");
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
var source3 = new PackageSource("Source3");
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2"));
mockRepository3.AddPackage(PackageUtility.CreatePackage("A", "1.4"));
mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, source3 });
mockFileSystemProvider.Setup(f => f.GetFileSystem(It.IsAny<string>())).Returns(new MockFileSystem());
mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny<string>())).Returns<string>(s =>
{
switch (s)
{
case "Source1": return mockRepository1;
case "Source2": return mockRepository2;
case "Source3": return mockRepository3;
default: return null;
}
});
var packageManagerFactory = new Mock<VsPackageManagerFactory>(new Mock<ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, mockFileSystemProvider.Object, new Mock<IRepositorySettings>().Object, new Mock<VsPackageInstallerEvents>().Object, mockRepository1, null);
packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny<string>())).Returns(new MockFileSystem());
// Act
var packageManager = packageManagerFactory.Object.CreatePackageManagerWithAllPackageSources(mockRepository1);
// Assert
Assert.IsType(typeof(PriorityPackageRepository), packageManager.SourceRepository);
var packageRestoreRepository = (PriorityPackageRepository)packageManager.SourceRepository;
Assert.Equal(mockRepository1, packageRestoreRepository.PrimaryRepository);
Assert.IsType(typeof(AggregateRepository), packageRestoreRepository.SecondaryRepository);
var secondaryRepository = (AggregateRepository)packageRestoreRepository.SecondaryRepository;
var secondaryRepositories = secondaryRepository.Repositories.ToList();
Assert.Equal(2, secondaryRepositories.Count);
Assert.Equal(mockRepository2, secondaryRepositories[0]);
Assert.Equal(mockRepository3, secondaryRepositories[1]);
}
public void InstallingPackageWithUnknownDependencyAndIgnoreDepencenciesInstallsPackageWithoutDependencies()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("C")
});
IPackage packageC = PackageUtility.CreatePackage("C", "1.0");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
// Act
packageManager.InstallPackage("A", version: null, ignoreDependencies: true, allowPrereleaseVersions: true);
// Assert
Assert.True(localRepository.Exists(packageA));
Assert.False(localRepository.Exists(packageC));
}
public void GetPackagesWithUpdatesTest()
{
// Arrange
var siteRoot = "x:\\";
var localRepository = new MockPackageRepository();
var sourceRepository = new MockServiceBasePackageRepository();
var projectSystem = new WebProjectSystem(siteRoot);
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(sourceRepository, pathResolver, projectSystem, localRepository);
var net40 = new FrameworkName(".NETFramework", new Version("4.0.0.0"));
var net45 = new FrameworkName(".NETFramework", new Version("4.5.0.0"));
IPackage packageA1 = PackageFactory.Create("A", new Version("1.0"), null);
IPackage packageA2 = PackageFactory.Create("A", new Version("2.0"), null, new FrameworkName[] { net45 });
IPackage packageB1 = PackageFactory.Create("B", new Version("1.0"), null);
IPackage packageB2 = PackageFactory.Create("B", new Version("2.0"), null, new FrameworkName[] { net40 });
sourceRepository.AddPackage(packageA1);
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageB1);
sourceRepository.AddPackage(packageB2);
localRepository.AddPackage(packageA1);
localRepository.AddPackage(packageB1);
// NOTE THAT target framework used by WebProjectManager would be .NETFramework, Version=4.0.0.0
var webProjectManager = new WebProjectManager(projectManager, siteRoot);
// Act
var packages = webProjectManager.GetPackagesWithUpdates(null, false).ToList();
// Assert
Assert.Equal(1, packages.Count);
Assert.Equal(packageB2, packages[0]);
}
public static void GetPackagesToBeReinstalledWhenProjectIsNotOfSupportedType()
{
// Arrange
Mock<Project> mockProject = new Mock<Project>();
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(PackageUtility.CreatePackage("A"));
mockProject.Setup(p => p.Kind).Returns(Guid.NewGuid().ToString());
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, localRepository);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public void InstallPackageCmdletCreatesFallbackRepository()
{
// Arrange
var productUpdateService = new Mock <IProductUpdateService>();
IPackageRepository repoA = new MockPackageRepository(), repoB = new MockPackageRepository();
var package = NuGet.Test.PackageUtility.CreatePackage("P1", dependencies: new[] { new PackageDependency("P2") });
repoA.AddPackage(package);
repoB.AddPackage(NuGet.Test.PackageUtility.CreatePackage("P2"));
var sharedRepo = new Mock <ISharedPackageRepository>();
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository("A")).Returns(repoA);
repositoryFactory.Setup(c => c.CreateRepository("B")).Returns(repoB);
var sourceProvider = GetPackageSourceProvider(new PackageSource("A"), new PackageSource("B"));
var fileSystemProvider = new Mock <IFileSystemProvider>();
fileSystemProvider.Setup(c => c.GetFileSystem(It.IsAny <string>(), It.IsAny <bool>())).Returns(new MockFileSystem());
var repositorySettings = new Mock <IRepositorySettings>();
repositorySettings.Setup(c => c.RepositoryPath).Returns(String.Empty);
var solutionManager = new Mock <ISolutionManager>();
var packageManagerFactory = new Mock <VsPackageManagerFactory>(solutionManager.Object, repositoryFactory.Object, sourceProvider, fileSystemProvider.Object, repositorySettings.Object, new Mock <VsPackageInstallerEvents>().Object);
packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny <string>())).Returns(new MockFileSystem());
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "P1";
cmdlet.Source = "A";
// Act
cmdlet.Execute();
// Assert
// If we've come this far, P1 is successfully installed.
Assert.True(true);
}
public void CreateFallbackRepositoryUsesResolvedSourceNameWhenEnsuringRepositoryIsNotAlreadyListedInAggregate()
{
// Arrange
var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>();
var mockSourceProvider = new Mock <IVsPackageSourceProvider>();
var mockRepository1 = new MockPackageRepository();
var mockRepository2 = new MockPackageRepository("http://redirected");
var aggregateRepo = new AggregateRepository(new[] { mockRepository1, mockRepository2 });
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
var aggregateSource = AggregatePackageSource.Instance;
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2"));
mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, aggregateSource });
mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s =>
{
switch (s)
{
case "Source1": return(mockRepository1);
case "Source2": return(mockRepository2);
default: return(null);
}
});
var packageManagerFactory = new VsPackageManagerFactory(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock <IFileSystemProvider>().Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object);
// Act
FallbackRepository repository = (FallbackRepository)packageManagerFactory.CreateFallbackRepository(mockRepository2);
// Assert
var dependencyResolver = (AggregateRepository)repository.DependencyResolver;
Assert.Equal(2, dependencyResolver.Repositories.Count());
}
public void UninstallProjectLevelPackageThrowsIfPackageIsReferenced()
{
// Arrange
var localRepository = new Mock <MockPackageRepository>()
{
CallBase = true
}.As <ISharedPackageRepository>();
localRepository.Setup(m => m.IsReferenced("foo", It.IsAny <Version>())).Returns(true);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
localRepository.Object.AddPackage(package);
sourceRepository.AddPackage(package);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock <IRecentPackageRepository>().Object);
var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), new MockPackageRepository());
// Act
ExceptionAssert.Throws <InvalidOperationException>(() => packageManager.UninstallPackage(projectManager, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance), @"Unable to find package 'foo 1.0' in 'C:\MockFileSystem\'.");
}
public void InstallPackageThrowsExceptionPackageIsNotInstalled()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new Mock <IProjectSystem>();
projectSystem.Setup(m => m.AddFile(@"A.1.0\content\file", It.IsAny <Stream>())).Throws <UnauthorizedAccessException>();
projectSystem.Setup(m => m.Root).Returns("FakeRoot");
PackageManager packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem.Object), projectSystem.Object, localRepository);
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { "file" });
sourceRepository.AddPackage(packageA);
// Act
ExceptionAssert.Throws <UnauthorizedAccessException>(() => packageManager.InstallPackage("A"));
// Assert
Assert.False(packageManager.LocalRepository.Exists(packageA));
}
public void InstallPackageSetOperationToInstall2()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, projectSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
sourceRepository.AddPackage(package);
// Act
packageManager.InstallPackage(projectManager, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, skipAssemblyReferences: false, logger: NullLogger.Instance);
// Assert
Assert.Equal("Install", sourceRepository.LastOperation);
Assert.Equal("foo", sourceRepository.LastMainPackageId);
Assert.Equal("1.0", sourceRepository.LastMainPackageVersion);
}
public void CanExecuteReturnsCorrectResult()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
var provider = CreateOnlineProvider(packageManager.Object, localRepository);
var extensionA = new PackageItem(provider, packageA);
var extensionB = new PackageItem(provider, packageB);
var extensionC = new PackageItem(provider, packageC);
// Act
bool canExecuteA = provider.CanExecute(extensionA);
bool canExecuteB = provider.CanExecute(extensionB);
bool canExecuteC = provider.CanExecute(extensionC);
// Assert
Assert.True(canExecuteC);
Assert.True(canExecuteB);
Assert.False(canExecuteA);
}
public void UpdatePackagesSetOperationToUpdate3()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, projectSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" });
localRepository.AddPackage(package);
projectRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("phuong", "2.0", new[] { "hello" });
sourceRepository.AddPackage(package2);
var packageB = PackageUtility.CreatePackage("time", "1.0", new[] { "hello" });
projectRepository.AddPackage(package);
// Act
packageManager.UpdatePackage(
projectManager,
"phuong",
version: null,
updateDependencies: true,
allowPrereleaseVersions: true,
logger: NullLogger.Instance);
// Assert
Assert.Equal("Update", sourceRepository.LastOperation);
Assert.Equal("phuong", sourceRepository.LastMainPackageId);
Assert.Equal("2.0", sourceRepository.LastMainPackageVersion);
}
public void PackageRestoreRepositoryExistsReturnsFalse()
{
// Arrange
var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>();
var mockSourceProvider = new Mock <IVsPackageSourceProvider>();
var mockRepository1 = new MockPackageRepository();
var mockRepository2 = new MockPackageRepository();
var mockRepository3 = new MockPackageRepository();
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
var source3 = new PackageSource("Source3");
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("B", "2.0"));
mockRepository3.AddPackage(PackageUtility.CreatePackage("C", "3.0"));
mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, source3 });
mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s =>
{
switch (s)
{
case "Source1": return(mockRepository1);
case "Source2": return(mockRepository2);
case "Source3": return(mockRepository3);
default: return(null);
}
});
// Act
var packageRestoreRepository = mockSourceProvider.Object.CreatePriorityPackageRepository(mockRepositoryFactory.Object, mockRepository1);
Assert.False(packageRestoreRepository.Exists("D", new SemanticVersion("1.0")));
}
public static void GetPackagesToBeReinstalledReturnsPackageTargetingSingleFrameworkBasedOnTools()
{
// Create a packageA which has as content only in net40. Create a package reference corresponding to this package with the project target framework as 'net40'
// Now, Try and check if the created packagereference on a project with targetframework of net35 will require reinstallation. IT SHOULD REQUIRE REINSTALLATION
// Arrange
IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0", null, null, tools: new[] { @"net40\init.ps1" });
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
List<PackageReference> packageReferences = new List<PackageReference>();
packageReferences.Add(new PackageReference("A", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false));
FrameworkName projectFramework = new FrameworkName(".NETFramework, Version=3.5");
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(projectFramework, packageReferences, localRepository);
// Assert
Assert.Equal(1, packagesToBeReinstalled.Count);
Assert.Equal(packagesToBeReinstalled[0].Id, "A");
}
public void InstallPackageRunsInitAndInstallScripts()
{
// Arrange
var localRepository = new Mock <MockPackageRepository>()
{
CallBase = true
}.As <ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectRepository = new MockProjectPackageRepository(localRepository);
var fileSystem = new MockFileSystem();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(new MockProjectSystem());
var project = TestUtils.GetProject("Foo");
var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository);
var scriptExecutor = new Mock <IScriptExecutor>();
var packageManager = new Mock <VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository,
new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object)
{
CallBase = true
};
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object);
packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager);
var package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, tools: new[] { "init.ps1", "install.ps1" });
sourceRepository.AddPackage(package);
var installer = new VsPackageInstaller(packageManagerFactory.Object, scriptExecutor.Object, new Mock <IPackageRepositoryFactory>().Object, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object);
// Act
installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false);
// Assert
scriptExecutor.Verify(e => e.Execute(It.IsAny <string>(), PowerShellScripts.Init, It.IsAny <IPackage>(), null, null, It.IsAny <ILogger>()), Times.Once());
scriptExecutor.Verify(e => e.Execute(It.IsAny <string>(), PowerShellScripts.Install, It.IsAny <IPackage>(), It.IsAny <Project>(), It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
}
public void CreateFallbackRepositoryReturnsCurrentIfCurrentIsAggregateRepository()
{
// Arrange
var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>();
var mockSourceProvider = new Mock <IVsPackageSourceProvider>();
var mockRepository1 = new MockPackageRepository();
var mockRepository2 = new MockPackageRepository();
var aggregateRepo = new AggregateRepository(new[] { mockRepository1, mockRepository2 });
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
var aggregateSource = AggregatePackageSource.Instance;
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2"));
mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, aggregateSource });
mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s =>
{
switch (s)
{
case "Source1": return(mockRepository1);
case "Source2": return(mockRepository2);
default: return(null);
}
});
var packageManagerFactory = new VsPackageManagerFactory(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock <IFileSystemProvider>().Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object, mockRepository1, machineWideSettings: null);
// Act
var repository = packageManagerFactory.CreateFallbackRepository(aggregateRepo);
// Assert
Assert.Equal(aggregateRepo, repository);
}
public void CreatePackageManagerForPackageRestoreUsesAggregateRepository()
{
// Arrange
var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>();
var mockSourceProvider = new Mock <IVsPackageSourceProvider>();
var mockFileSystemProvider = new Mock <IFileSystemProvider>();
var mockRepository1 = new MockPackageRepository("Source1");
var mockRepository2 = new MockPackageRepository("Source2");
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2"));
var aggregateRepository = new AggregateRepository(new [] { mockRepository1, mockRepository2 });
//mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2 });
mockFileSystemProvider.Setup(f => f.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem());
var packageManagerFactory = new Mock <VsPackageManagerFactory>(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, mockFileSystemProvider.Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object, mockRepository1, null);
packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny <string>())).Returns(new MockFileSystem());
// Act
var packageManager = packageManagerFactory.Object.CreatePackageManagerWithAllPackageSources(aggregateRepository);
// Assert
Assert.IsType(typeof(AggregateRepository), packageManager.SourceRepository);
var sourceAggregateRepository = (AggregateRepository)packageManager.SourceRepository;
var repositories = sourceAggregateRepository.Repositories.ToList();
Assert.Equal(2, repositories.Count);
Assert.Equal(mockRepository1, repositories[0]);
Assert.Equal(mockRepository2, repositories[1]);
}
public void InstallPackageInstallsIntoProjectAndPackageManager()
{
// Arrange
var localRepository = new Mock <MockPackageRepository>()
{
CallBase = true
}.As <ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock <IRecentPackageRepository>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
sourceRepository.AddPackage(package);
// Act
packageManager.InstallPackage(projectManager, "foo", new Version("1.0"), ignoreDependencies: false, logger: NullLogger.Instance);
// Assert
Assert.IsTrue(packageManager.LocalRepository.Exists(package));
Assert.IsTrue(projectManager.LocalRepository.Exists(package));
}
public void UninstallPackageRemovesPackageIfPackageIsNotReferenced()
{
// Arrange
var localRepository = new Mock <MockPackageRepository>()
{
CallBase = true
}.As <ISharedPackageRepository>();
localRepository.Setup(m => m.IsReferenced("foo", It.IsAny <Version>())).Returns(false);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
localRepository.Object.AddPackage(package);
sourceRepository.AddPackage(package);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock <IRecentPackageRepository>().Object);
// Act
packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance);
// Assert
Assert.IsFalse(packageManager.LocalRepository.Exists(package));
}
public static void GetPackagesToBeReinstalledReturnsEmptyListForPackageTargetingMultipleFrameworks()
{
// Create a packageA which has as assembly reference in net 20 and net30. Create a package reference corresponding to this package with the project target framework as 'net40'
// Now, Try and check if the created packagereference on a project with targetframework of net35 will require reinstallation. IT SHOULD REQUIRE REINSTALLATION
// Arrange
IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0", null, assemblyReferences: new[] { @"lib\net20\bar.dll", @"lib\net30\foo.dll" });
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
List <PackageReference> packageReferences = new List <PackageReference>();
packageReferences.Add(new PackageReference("A", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false));
FrameworkName projectFramework = new FrameworkName(".NETFramework, Version=3.5");
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(projectFramework, packageReferences, localRepository);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public void SolutionInstalledProviderShowsAllVersions()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageA2 = PackageUtility.CreatePackage("A", "2.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageA2);
localRepository.AddPackage(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
provider.SelectedNode = firstTreeNode;
firstTreeNode.IsSelected = true;
var mre = new ManualResetEventSlim(false);
firstTreeNode.PackageLoadCompleted += delegate
{
var allExtensions = firstTreeNode.Extensions;
// Assert
Assert.Equal(3, allExtensions.Count);
Assert.Equal("A", allExtensions[0].Id);
Assert.Equal("1.0", ((PackageItem)allExtensions[0]).Version);
Assert.Equal("A", allExtensions[1].Id);
Assert.Equal("2.0", ((PackageItem)allExtensions[1]).Version);
Assert.Equal("B", allExtensions[2].Id);
Assert.Equal("2.0", ((PackageItem)allExtensions[2]).Version);
mre.Set();
};
// Act
var ignore = firstTreeNode.Extensions;
mre.Wait();
}
public void ExecuteUninstallsSolutionLevelPackageWhenUpdating()
{
// Arrange
var packageA_10 = PackageUtility.CreatePackage("A", "1.0", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null);
var packageA_12 = PackageUtility.CreatePackage("A", "1.2", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA_12);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA_10);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.LocalRepository).Returns(localRepository);
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.IsProjectLevel(packageA_12)).Returns(false);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[0]);
var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA_10);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception exception = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
mockPackageManager.Verify(p => p.UpdatePackage(
new Project[0],
packageA_12,
new[] { new PackageOperation(packageA_10, PackageAction.Uninstall), new PackageOperation(packageA_12, PackageAction.Install) },
true,
false,
provider,
provider), Times.Once());
}
catch (Exception e)
{
exception = e;
}
finally
{
manualEvent.Set();
}
};
var extensionA_12 = new PackageItem(provider, packageA_12);
// Act
provider.Execute(extensionA_12);
// do not allow the method to return
manualEvent.Wait();
Assert.Null(exception);
}
public void ExecuteMethodInstallPackagesWithInitScript()
{
// source repo has A, B, C
// solution repo has A
// project repo has C
// install B
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0", content: new string[] { "hello world" }, tools: new string[] { "init.ps1" });
var packageC = PackageUtility.CreatePackage("C", "3.0");
var solutionRepository = new MockPackageRepository();
solutionRepository.AddPackage(packageA);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
var localRepository = new MockPackageRepository();
localRepository.Add(packageC);
var projectManager = CreateProjectManager(localRepository, solutionRepository);
var project = new Mock <Project>();
project.Setup(p => p.Properties.Item("TargetFrameworkMoniker").Value).Returns(".NETFramework, Version=4.0");
var scriptExecutor = new Mock <IScriptExecutor>();
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.LocalRepository).Returns(solutionRepository);
packageManager.Setup(p => p.InstallPackage(projectManager, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>())).
Raises(p => p.PackageInstalled += null, packageManager, new PackageOperationEventArgs(packageB, null, ""));
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var provider = CreateOnlineProvider(packageManager.Object, null, null, null, project.Object, scriptExecutor.Object, solutionManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
ManualResetEvent manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
// init.ps1 should be executed
scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), PowerShellScripts.Init, packageB, null, null, It.IsAny <ILogger>()), Times.Once());
// InstallPackage() should get called
packageManager.Verify(p => p.InstallPackage(
projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>()), Times.Once());
}
finally
{
manualEvent.Set();
}
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.WaitOne();
}
public void SearchTreeNodeHonorsTheIncludePrereleaseAttribute(bool includePrerelease, string expectedVersion)
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("packageA", "1.0");
var packageA2 = PackageUtility.CreatePackage("packageA", "2.0-alpha");
var packageC = PackageUtility.CreatePackage("packageB", "3.0.0.0-rtm");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageA1);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA2);
var projectManager = new Mock <IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(localRepository);
var project = new Mock <Project>();
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var provider = CreateOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, project: project.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA2);
firstTreeNode.Repository.AddPackage(packageA1);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
mockPackageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object);
var manualEvent = new ManualResetEventSlim(false);
// Act 1
var treeNode = (PackagesTreeNodeBase)provider.Search("packageA");
Assert.NotNull(treeNode);
Exception exception = null;
treeNode.PackageLoadCompleted += (o, e) =>
{
try
{
var packages = treeNode.Extensions.OfType <PackageItem>().ToList();
Assert.Equal(1, packages.Count);
AssertPackage(packages[0].PackageIdentity, "packageA", expectedVersion);
}
catch (Exception ex)
{
exception = ex;
}
finally
{
manualEvent.Set();
}
};
// trigger loading packages
var extensions = treeNode.Extensions;
// do not allow the method to return
manualEvent.Wait();
if (exception != null)
{
throw exception;
}
}
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 ExecuteAllMethodCallUpdateAllPackageOnAllProjects(bool includePrerelease)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var packageB2 = PackageUtility.CreatePackage("B", "4.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageB2);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var extensionB2 = new PackageItem(provider, packageB2);
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
firstTreeNode.Extensions.Add(extensionB2);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception exception = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation);
mockPackageManager.Verify(
p => p.UpdatePackages(true, includePrerelease, provider, provider),
Times.Once());
}
catch (Exception ex)
{
exception = ex;
}
finally
{
manualEvent.Set();
}
};
// Act
provider.Execute(item: null);
// do not allow the method to return
manualEvent.Wait();
Assert.Null(exception);
}
public void UninstallingSatellitePackageRemovesFilesFromRuntimePackageFolder()
{
// 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",
assemblyReferences: new[] {
@"lib\foo.dll"
},
content: new[] {
@"english.txt"
});
var satellitePackage = PackageUtility.CreatePackage(
"foo.ja-jp", "1.0.0", language: "ja-jp",
satelliteAssemblies: new[] {
@"lib\ja-jp\foo.resources.dll",
@"lib\ja-jp\foo.xml",
@"lib\japanese.xml"
},
content: new[] {
@"english.txt",
@"japanese.txt"
},
dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.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(2, packagesFolder.Paths.Count);
Assert.True(packagesFolder.FileExists(@"foo.1.0.0\content\english.txt"));
Assert.True(packagesFolder.FileExists(@"foo.1.0.0\lib\foo.dll"));
Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\ja-jp\foo.resources.dll"));
Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\ja-jp\foo.xml"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\content\english.txt"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\content\japanese.txt"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\japanese.xml"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.resources.dll"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.xml"));
Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\japanese.xml"));
Assert.False(packagesFolder.FileExists(@"foo.1.0.0\content\japanese.txt"));
}
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 ExecuteMethodCallsInstallPackageMethodOnPackageManager(bool includePrerelease)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
Assert.Equal(RepositoryOperationNames.Install, sourceRepository.LastOperation);
mockPackageManager.Verify(p => p.InstallPackage(
new Project[] { project1, project2 },
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
includePrerelease,
provider,
provider), Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public void ExecuteMethodDoNotCallInstallPackageIfUserDoesNotSelectAnyProject()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[0]);
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
mockPackageManager.Verify(p => p.InstallPackage(
It.IsAny <IEnumerable <Project> >(),
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
false,
provider,
provider), Times.Never());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public void InstallPackageInvokeInstallScript()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0", tools: new[] { "install.ps1" });
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
var fileSystem = new Mock <IVsProjectSystem>();
fileSystem.SetupGet(f => f.UniqueName).Returns("Project1");
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
projectManager1.Setup(p => p.AddPackageReference(packageB, false, false))
.Raises(p => p.PackageReferenceAdded += (o, a) => { }, new PackageOperationEventArgs(packageB, fileSystem.As <IFileSystem>().Object, "x:\\nuget"));
var project1 = MockProjectUtility.CreateMockProject("Project1");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
packageManager.Setup(p => p.InstallPackage(
new[] { project1 },
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
false,
It.IsAny <ILogger>(),
It.IsAny <IPackageOperationEventListener>()))
.Callback(
(IEnumerable <Project> projects,
IPackage package,
IEnumerable <PackageOperation> operations,
bool ignoreDependencies,
bool allowPrereleaseVersions,
ILogger logger,
IPackageOperationEventListener eventListener) =>
{
eventListener.OnBeforeAddPackageReference(project1);
projectManager1.Object.AddPackageReference(packageB, false, false);
});
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 });
var scriptExecutor = new Mock <IScriptExecutor>();
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, scriptExecutor: scriptExecutor.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception callbackException = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
scriptExecutor.Verify(p => p.Execute("x:\\nuget", "install.ps1", packageB, project1, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
}
catch (Exception exception)
{
callbackException = exception;
}
finally
{
manualEvent.Set();
}
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
if (callbackException != null)
{
throw callbackException;
}
}
public void ExecuteMethodCallsUpdatePackageMethodOnPackageManager(bool includePrerelease)
{
// Local repository contains Package A 1.0 and Package B
// Source repository contains Package A 2.0 and Package C
var packageA1 = PackageUtility.CreatePackage("A", "1.0");
var packageA2 = PackageUtility.CreatePackage("A", "2.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
// Arrange
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA1);
localRepository.AddPackage(packageB);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageC);
var project = new Mock <Project>();
var projectManager = new Mock <IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(localRepository);
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var mockWindowServices = new Mock <IUserNotifierServices>();
var provider = CreateUpdatesProvider(packageManager.Object, localRepository, project: project.Object, userNotifierServices: mockWindowServices.Object, solutionManager: solutionManager.Object);
provider.IncludePrerelease = includePrerelease;
var extensionA = new PackageItem(provider, packageA2);
var extensionC = new PackageItem(provider, packageC);
provider.SelectedNode = (UpdatesTreeNode)provider.ExtensionsTree.Nodes[0];
var manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation);
mockWindowServices.Verify(p => p.ShowLicenseWindow(It.IsAny <IEnumerable <IPackage> >()), Times.Never());
packageManager.Verify(p => p.UpdatePackage(projectManager.Object, packageA2, It.IsAny <IEnumerable <PackageOperation> >(), true, includePrerelease, provider), Times.Once());
manualEvent.Set();
};
// Act
provider.Execute(extensionA);
// do not allow the method to return
manualEvent.WaitOne();
}
public void ExecuteMethodInvokeInstallScriptAndUninstallScript()
{
// Local repository contains Package A 1.0 and Package B
// Source repository contains Package A 2.0 and Package C
var packageA1 = PackageUtility.CreatePackage("A", "1.0", tools: new string[] { "uninstall.ps1" });
var packageA2 = PackageUtility.CreatePackage("A", "2.0", content: new string[] { "hello world" }, tools: new string[] { "install.ps1" });
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
// Arrange
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA1);
localRepository.AddPackage(packageB);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageC);
var project = new Mock <Project>();
var projectManager = CreateProjectManager(localRepository, sourceRepository);
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager);
packageManager.Setup(p => p.UpdatePackage(
projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), true, false, It.IsAny <ILogger>())).Callback(
() =>
{
projectManager.AddPackageReference("A", new SemanticVersion("2.0"), false, false);
});
var scriptExecutor = new Mock <IScriptExecutor>();
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var provider = CreateUpdatesProvider(packageManager.Object, localRepository, null, null, project.Object, scriptExecutor.Object, null, solutionManager.Object);
provider.SelectedNode = (UpdatesTreeNode)provider.ExtensionsTree.Nodes[0];
var extensionA = new PackageItem(provider, packageA2);
ManualResetEvent manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
try
{
scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), "uninstall.ps1", packageA1, project.Object, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), "install.ps1", packageA2, project.Object, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
}
finally
{
manualEvent.Set();
}
};
// Act
provider.Execute(extensionA);
// do not allow the method to return
manualEvent.WaitOne();
}
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
provider.SelectedNode = firstTreeNode;
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
packageManager.Verify(p => p.InstallPackage(
projectManager1.Object,
packageB.Id,
packageB.Version,
false,
true,
provider),
Times.Once());
packageManager.Verify(p => p.InstallPackage(
projectManager2.Object,
packageB.Id,
packageB.Version,
false,
true,
provider),
Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public void CallingEnableCurrentSolutionDoNotDownloadPackageIfPresentInLocalCache()
{
// Arrange
string tempSolutionPath = CreateTempFolder();
// setup SolutionManager
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.IsSolutionOpen).Returns(true);
solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath);
// setup file system
var fileSystem = new PhysicalFileSystem(tempSolutionPath);
var fileSystemProvider = new Mock <IFileSystemProvider>(MockBehavior.Strict);
fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem);
var nugetFolderFileSystem = new PhysicalFileSystem(tempSolutionPath + "\\.nuget");
fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath + "\\.nuget")).Returns(nugetFolderFileSystem);
// setup DTE
var dte = new Mock <DTE>();
var projectItems = new Mock <ProjectItems>();
var solutionFolder = new Mock <Project>();
solutionFolder.Setup(s => s.Name).Returns(".nuget");
solutionFolder.SetupGet(s => s.ProjectItems).Returns(projectItems.Object);
var solution = new Mock <Solution>();
solution.As <Solution2>().Setup(p => p.AddSolutionFolder(".nuget")).Returns(solutionFolder.Object);
var projects = new MockProjects(new Project[0]);
solution.As <Solution2>().Setup(s => s.Projects).Returns(projects);
dte.SetupGet(p => p.Solution).Returns(solution.Object);
// setup package repository
var packageRepository = new MockPackageRepository();
var packageA = new Mock <IPackage>(MockBehavior.Strict);
packageA.Setup(p => p.Id).Returns("NuGet.Build");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
packageA.Setup(p => p.IsLatestVersion).Returns(true);
packageA.Setup(p => p.Listed).Returns(true);
var packageB = new Mock <IPackage>(MockBehavior.Strict);
packageB.Setup(p => p.Id).Returns("NuGet.CommandLine");
packageB.Setup(p => p.Version).Returns(new SemanticVersion("2.0"));
packageB.Setup(p => p.IsLatestVersion).Returns(true);
packageB.Setup(p => p.Listed).Returns(true);
packageRepository.AddPackage(packageA.Object);
packageRepository.AddPackage(packageB.Object);
var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict);
packageRepositoryFactory.Setup(p => p.CreateRepository("x:\\nugetsource")).Returns(packageRepository);
var packageSourceProvider = new Mock <IVsPackageSourceProvider>();
packageSourceProvider.Setup(p => p.LoadPackageSources()).Returns(new[]
{
new PackageSource("x:\\nugetsource"),
new PackageSource("y:\\me", "unabled", isEnabled: false),
});
var localCache = new MockPackageRepository();
localCache.Add(PackageUtility.CreatePackage(
"NuGet.Build",
version: "1.0",
tools: new string[] { "NuGet.targets" },
dependencies: new PackageDependency[] { new PackageDependency("NuGet.CommandLine") },
listed: true));
localCache.Add(PackageUtility.CreatePackage(
"NuGet.CommandLine",
version: "2.0",
tools: new string[] { "NuGet.exe" },
listed: true));
var packageRestore = CreateInstance(
dte.Object,
solutionManager.Object,
fileSystemProvider.Object,
packageRepositoryFactory.Object,
localCache: localCache,
packageSourceProvider: packageSourceProvider.Object);
// Act
packageRestore.EnableCurrentSolutionForRestore(fromActivation: false);
// Assert
packageA.Verify(p => p.GetFiles(), Times.Never());
packageB.Verify(p => p.GetFiles(), Times.Never());
}
