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 scriptExecutor = new Mock <IScriptExecutor>();
var packageManager = new MockVsPackageManager2(
@"c:\solution",
sourceRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager);
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 <IOutputConsoleProvider>().Object, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, null);
// 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 InstallPackageConsidersAlreadyInstalledPrereleasePackagesWhenResolvingDependencies()
{
// Arrange
var packageB_05 = PackageUtility.CreatePackage("B", "0.5.0");
var packageB_10a = PackageUtility.CreatePackage("B", "1.0.0-a");
var packageA = PackageUtility.CreatePackage("A",
dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("[0.5.0, 2.0.0)")) });
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB_10a);
sourceRepository.AddPackage(packageB_05);
// Act
// The allowPrereleaseVersions flag should be irrelevant since we specify a version.
packageManager.InstallPackage("B", version: new SemanticVersion("1.0.0-a"), ignoreDependencies: false, allowPrereleaseVersions: false);
// Verify we actually did install B.1.0.0a
Assert.True(localRepository.Exists(packageB_10a));
packageManager.InstallPackage("A");
// Assert
Assert.True(localRepository.Exists(packageA));
Assert.True(localRepository.Exists(packageB_10a));
}
public void XdtTransformOnXmlNodeWithAttributes()
{
// Arrange
var mockProjectSystem = new MockProjectSystem();
var mockRepository = new MockPackageRepository();
mockProjectSystem.AddFile("test.xml",
@"<a attrib=""b""/>".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\test.xml.install.xdt");
file.Setup(m => m.EffectivePath).Returns("test.xml.install.xdt");
file.Setup(m => m.GetStream()).Returns(() =>
@"<a xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform""><test xdt:Transform=""InsertIfMissing""/></a>".AsStream());
package.Setup(m => m.GetFiles()).Returns(new[] { file.Object });
mockRepository.AddPackage(package.Object);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(mockProjectSystem.FileExists("test.xml"));
var actual = mockProjectSystem.OpenFile("test.xml").ReadToEnd();
Assert.Equal("<a attrib=\"b\">\t<test/></a>", actual);
}
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 UpdatePackagesSetOperationToUpdate1()
{
// 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);
// Act
packageManager.UpdatePackages(
projectManager,
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 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);
// Assert
Assert.IsTrue(localRepository.Exists(packageA));
Assert.IsFalse(localRepository.Exists(packageC));
}
public void UninstallingPackageUninstallsPackageButNotDependencies()
{
// 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("B")
});
IPackage packageB = PackageUtility.CreatePackage("B", "1.0");
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
// Act
packageManager.UninstallPackage("A");
// Assert
Assert.False(localRepository.Exists(packageA));
Assert.True(localRepository.Exists(packageB));
}
public void UpdatePackageWillAskForEachFileWhenThereAreFileConflict()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var constraintProvider = NullConstraintProvider.Instance;
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var projectSystem = new MockProjectSystem();
projectSystem.AddFile("one.txt", "this is one");
projectSystem.AddFile("two.txt", "this is two");
var packages = new List <IPackage>();
var package_A10 = PackageUtility.CreatePackage("A", "1.0", content: new[] { "1.txt" });
var package_A12 = PackageUtility.CreatePackage("A", "1.2", content: new[] { "one.txt", "two.txt" });
localRepository.Add(package_A10);
sourceRepository.Add(package_A12);
var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.AddPackage(package_A12)).Callback <IPackage>(p => packages.Add(p));
sharedRepository.Setup(s => s.GetPackages()).Returns(packages.AsQueryable());
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(s => s.CreateRepository(It.IsAny <string>())).Returns(sourceRepository);
var packageSourceProvider = new Mock <IPackageSourceProvider>();
packageSourceProvider.Setup(s => s.LoadPackageSources()).Returns(new[] { new PackageSource("foo-source") });
var answers = new[] {
FileConflictResolution.Overwrite,
FileConflictResolution.Ignore,
};
int cursor = 0;
var console = new Mock <IConsole>();
console.Setup(c => c.ResolveFileConflict(It.IsAny <string>())).Returns(() => answers[cursor++]);
var updateCommand = new UpdateCommand()
{
RepositoryFactory = repositoryFactory.Object,
SourceProvider = packageSourceProvider.Object,
Console = console.Object,
};
// Act
updateCommand.UpdatePackages(localRepository, fileSystem, sharedRepository.Object, sourceRepository, constraintProvider, pathResolver, projectSystem);
// Assert
Assert.True(localRepository.Exists("A", new SemanticVersion("1.2")));
Assert.Equal("content\\one.txt", projectSystem.ReadAllText("one.txt"));
Assert.Equal("this is two", projectSystem.ReadAllText("two.txt"));
Assert.Equal(2, cursor);
}
public void InstallPackageDoesNotPerformWalkInfoCheckWhenPassingTheFlag()
{
// In this test, we simulate installing a solution-level package which depends on
// a project-level package. Under normal condition, this is disallowed by NuGet.
// However, if passing the 'ignoreWalkInfo' parameter with value of 'true',
// NuGet will happily accept that. Hence the installation will succeed.
// This is used by the package restore mode.
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
// A is solution-level package
IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0",
tools: new string[] { "init.ps1" },
dependencies: new[] {
new PackageDependency("C")
});
IPackage packageC = PackageUtility.CreatePackage("C", "1.0.0-RC-1", content: new string[] { "a.txt" });
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
// Act
packageManager.InstallPackage(packageA, ignoreDependencies: false, allowPrereleaseVersions: true, ignoreWalkInfo: true);
// Assert
Assert.True(localRepository.Exists(packageA));
Assert.True(localRepository.Exists(packageC));
}
public void InstallSatellitePackageCopiesFilesToExistingRuntimePackageFolder()
{
// 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" });
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" },
dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.0.0]")) });
var projectSystem = new MockProjectSystem();
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
sourceRepository.AddPackage(runtimePackage);
sourceRepository.AddPackage(satellitePackage);
// Act
Install("foo", new NullProjectManager(packageManager));
Install("foo.ja-jp", new NullProjectManager(packageManager));
// Assert
Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\foo.dll"));
Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\foo.resources.dll"));
Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\foo.xml"));
Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.resources.dll"));
Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.xml"));
}
public void InstallPackageAddsAllFilesToFileSystem()
{
// Arrange
var projectSystem = new MockProjectSystem();
var sourceRepository = new MockPackageRepository();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem);
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "contentFile", @"sub\contentFile" },
new[] { @"lib\reference.dll" },
new[] { @"readme.txt" });
sourceRepository.AddPackage(packageA);
// Act
packageManager.InstallPackage("A");
// Assert
Assert.AreEqual(0, projectSystem.References.Count);
Assert.AreEqual(5, projectSystem.Paths.Count);
Assert.IsTrue(projectSystem.FileExists(@"A.1.0\content\contentFile"));
Assert.IsTrue(projectSystem.FileExists(@"A.1.0\content\sub\contentFile"));
Assert.IsTrue(projectSystem.FileExists(@"A.1.0\lib\reference.dll"));
Assert.IsTrue(projectSystem.FileExists(@"A.1.0\tools\readme.txt"));
Assert.IsTrue(projectSystem.FileExists(@"A.1.0\A.1.0.nupkg"));
}
public void InstallPackageDisregardTargetFrameworkOfDependencies()
{
// 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.0",
dependencies: new[] {
new PackageDependency("C", null)
});
IPackage packageC = PackageUtility.CreatePackage("C", "1.0.0");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
// Act
packageManager.InstallPackage("A", version: null, ignoreDependencies: false, allowPrereleaseVersions: true);
// Assert
Assert.True(localRepository.Exists(packageA));
Assert.True(localRepository.Exists(packageC));
}
public void InstallPackageInstallsLowerReleaseVersionIfPrereleaseFlagIsNotSet()
{
// 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.0",
dependencies: new[] {
new PackageDependency("C")
});
IPackage packageC_RC = PackageUtility.CreatePackage("C", "1.0.0-RC-1");
IPackage packageC = PackageUtility.CreatePackage("C", "0.9");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageC_RC);
// Act
packageManager.InstallPackage("A", version: null, ignoreDependencies: false, allowPrereleaseVersions: false);
// Assert
Assert.True(localRepository.Exists(packageA));
Assert.True(localRepository.Exists(packageC));
}
public void InstallPackageInstallsSemVer200PrereleasePackageWithVersionGiven()
{
// 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.0-beta.1.2+git.hash.21d2b3f0acb1c8ffe9909bf2f1cbed2273414e58",
dependencies: new[] {
new PackageDependency("C", VersionUtility.ParseVersionSpec("2.0.0-beta.2.2+other.data"))
});
IPackage packageC = PackageUtility.CreatePackage("C", "2.0.0-beta.2.2+git.hash.a1d2b3f0acb1c8ffe9909bf2f1cbed2273414e58");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
// Act
packageManager.InstallPackage("A", version: SemanticVersion.Parse("1.0.0-beta.1.2+other.data"), ignoreDependencies: false, allowPrereleaseVersions: true);
// Assert
Assert.True(localRepository.Exists(packageA));
Assert.True(localRepository.Exists(packageC));
}
public void UpdatePackageAddsPackagesToSharedPackageRepositoryWhenReferencesAreAdded()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var constraintProvider = NullConstraintProvider.Instance;
var pathResolver = new DefaultPackagePathResolver(NullFileSystem.Instance);
var projectSystem = new MockProjectSystem();
var package_A10 = PackageUtility.CreatePackage("A", "1.0", content: new[] { "1.txt" });
var package_A12 = PackageUtility.CreatePackage("A", "1.2", content: new[] { "1.txt" });
localRepository.Add(package_A10);
sourceRepository.Add(package_A12);
var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.AddPackage(package_A12)).Verifiable();
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(s => s.CreateRepository(It.IsAny <string>())).Returns(sourceRepository);
var packageSourceProvider = new Mock <IPackageSourceProvider>();
packageSourceProvider.Setup(s => s.LoadPackageSources()).Returns(new[] { new PackageSource("foo-source") });
var updateCommand = new UpdateCommand(repositoryFactory.Object, packageSourceProvider.Object);
// Act
updateCommand.UpdatePackages(localRepository, sharedRepository.Object, sourceRepository, constraintProvider, pathResolver, projectSystem);
// Assert
sharedRepository.Verify();
}
public void UninstallingSatellitePackageRemovesCollidingRuntimeFiles()
{
// Arrange
// Create a runtime package and a satellite package that has a dependency on the runtime package, and uses the
// local suffix convention.
var runtimePackage = PackageUtility.CreatePackage("foo", "1.0.0",
assemblyReferences: new[] { @"lib\ja-jp\collision.txt" });
var satellitePackage = PackageUtility.CreatePackage("foo.ja-jp", "1.0.0", language: "ja-jp",
satelliteAssemblies: new[] { @"lib\ja-jp\collision.txt" },
dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.0.0]")) });
var projectSystem = new MockProjectSystem();
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
sourceRepository.AddPackage(runtimePackage);
sourceRepository.AddPackage(satellitePackage);
// Act
packageManager.InstallPackage("foo");
packageManager.InstallPackage("foo.ja-jp");
packageManager.UninstallPackage("foo.ja-jp");
// Assert
Assert.Equal(0, projectSystem.Paths.Count);
Assert.False(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\collision.txt"));
}
public void ReInstallingPackageAfterUninstallingDependencyShouldReinstallAllDependencies()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
PackageManager packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("B")
});
IPackage packageB = PackageUtility.CreatePackage("B", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("C")
});
var packageC = PackageUtility.CreatePackage("C", "1.0");
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
// Act
packageManager.InstallPackage("A");
// Assert
Assert.IsTrue(localRepository.Exists(packageA));
Assert.IsTrue(localRepository.Exists(packageB));
Assert.IsTrue(localRepository.Exists(packageC));
}
public void InstallPackagesFromVSExtensionRepositoryThrowsWhenPackageIsMissing()
{
// Arrange
var extensionId = "myExtensionId";
var extensionManagerMock = new Mock <IVsExtensionManager>();
var extensionMock = new Mock <IInstalledExtension>();
extensionMock.Setup(e => e.InstallPath).Returns(@"C:\Extension\Dir");
var extension = extensionMock.Object;
extensionManagerMock.Setup(em => em.TryGetInstalledExtension(extensionId, out extension)).Returns(true);
var services = new Mock <IVsPackageInstallerServices>();
services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), It.IsAny <string>())).Returns(false);
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(null, pathResolver, projectSystem, projectRepository);
var packageManager = new Mock <VsPackageManager>(
TestUtils.GetSolutionManager(),
sourceRepository,
new Mock <IFileSystemProvider>().Object,
fileSystem,
localRepository,
new Mock <IDeleteOnRestartManager>().Object,
new Mock <VsPackageInstallerEvents>().Object,
/* multiFrameworkTargeting */ null)
{
CallBase = true
};
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object);
packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager);
packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable();
var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, null, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, services.Object, extensionManagerMock.Object);
var packages = new Dictionary <string, string>();
packages.Add("A", "1.0.0");
// Act & Assert
var exception = Assert.Throws <InvalidOperationException>(() => installer.InstallPackagesFromVSExtensionRepository(extensionId, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages));
Assert.True(exception.Message.Contains("A.1.0.0 : "));
}
public void InstallPackageDoesNotTurnOffBindingRedirectIfNotSkipAssemblyReferences()
{
// 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,
/* multiFrameworkTargeting */ null)
{
CallBase = true
};
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManager.As <IVsPackageManager>().SetupGet(m => m.BindingRedirectEnabled).Returns(true);
packageManager.As <IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = false);
packageManager.As <IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = true);
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 <IOutputConsoleProvider>().Object,
new Mock <IVsCommonOperations>().Object,
new Mock <ISolutionManager>().Object,
null,
null);
// Act
installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false);
// Assert
packageManager.As <IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = false, Times.Never());
packageManager.As <IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = true, Times.Exactly(2));
}
public void RemovePackageWithXdtTransformFile()
{
// Arrange
var mockProjectSystem = new MockProjectSystem();
var mockRepository = new MockPackageRepository();
mockProjectSystem.AddFile("web.config",
@"<configuration>
<system.web><compilation debug=""false"" /></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.uninstall.xdt");
file.Setup(m => m.EffectivePath).Returns("web.config.uninstall.xdt");
file.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 });
mockRepository.AddPackage(package.Object);
// Act 1
projectManager.AddPackageReference("A");
// Assert 1
Assert.False(mockProjectSystem.FileExists("web.config.uninstall.xdt"));
Assert.Equal(
@"<configuration>
<system.web><compilation debug=""false"" /></system.web>
</configuration>
", mockProjectSystem.OpenFile("web.config").ReadToEnd());
// Act 2
projectManager.RemovePackageReference("A");
// Assert 2
Assert.False(mockProjectSystem.FileExists("web.config.uninstall.xdt"));
Assert.True(mockProjectSystem.FileExists("web.config"));
Assert.Equal(
@"<configuration>
<system.web></system.web>
</configuration>
", mockProjectSystem.OpenFile("web.config").ReadToEnd());
}
public void InstallPackagesFromRegistryRepositoryThrowsWhenPackageIsMissing()
{
// Arrange
var registryPath = @"SOFTWARE\NuGet\Repository";
var registryKey = "PreinstalledPackages";
var registryValue = @"C:\PreinstalledPackages";
var hkcu_repository = new Mock <IRegistryKey>();
var hkcu = new Mock <IRegistryKey>();
hkcu_repository.Setup(k => k.GetValue(registryKey)).Returns(registryValue);
hkcu.Setup(r => r.OpenSubKey(registryPath)).Returns(hkcu_repository.Object);
var services = new Mock <IVsPackageInstallerServices>();
services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), It.IsAny <string>())).Returns(false);
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(null, pathResolver, projectSystem, projectRepository);
var packageManager = new Mock <VsPackageManager>(
TestUtils.GetSolutionManager(),
sourceRepository,
new Mock <IFileSystemProvider>().Object,
fileSystem,
localRepository,
new Mock <IDeleteOnRestartManager>().Object,
new Mock <VsPackageInstallerEvents>().Object,
/* multiFrameworkTargeting */ null)
{
CallBase = true
};
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object);
packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager);
packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable();
var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, null, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, services.Object, registryKeys: new[] { hkcu.Object });
var packages = new Dictionary <string, string>();
packages.Add("A", "1.0.0");
// Act & Assert
var exception = Assert.Throws <InvalidOperationException>(() => installer.InstallPackagesFromRegistryRepository(registryKey, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages));
Assert.True(exception.Message.Contains("A.1.0.0 : "));
}
/* !!! Should be changed to a test using Install-Package cmdlet
* [Fact]
* public void ReInstallingPackageAfterUninstallingDependencyShouldReinstallAllDependencies()
* {
* // Arrange
* var localRepository = new MockSharedPackageRepository();
* var sourceRepository = new MockPackageRepository();
* var projectSystem = new MockProjectSystem();
* PackageManager packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
*
* IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
* dependencies: new List<PackageDependency> {
* new PackageDependency("B")
* });
*
* IPackage packageB = PackageUtility.CreatePackage("B", "1.0",
* dependencies: new List<PackageDependency> {
* new PackageDependency("C")
* });
*
* var packageC = PackageUtility.CreatePackage("C", "1.0");
*
* localRepository.AddPackage(packageA);
* localRepository.AddPackage(packageB);
*
* sourceRepository.AddPackage(packageA);
* sourceRepository.AddPackage(packageB);
* sourceRepository.AddPackage(packageC);
*
* // Act
* packageManager.InstallPackage("A");
*
* // Assert
* Assert.True(localRepository.Exists(packageA));
* Assert.True(localRepository.Exists(packageB));
* Assert.True(localRepository.Exists(packageC));
* } */
/* !!! Should be changed to a test using Install-Package cmdlet
* [Fact]
* public void InstallPackageThrowsExceptionPackageIsNotInstalled()
* {
* // Arrange
* var localRepository = new MockSharedPackageRepository();
* var sourceRepository = new MockPackageRepository();
* var projectSystem = new Mock<IProjectSystem>();
* projectSystem.Setup(m => m.AddFiles(It.IsAny<IEnumerable<IPackageFile>>(), "A.1.0"))
* .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));
* } */
/* !!! Should be changed to a test using Install-Package cmdlet
* [Fact]
* public void UpdatePackageDoesNothingIfNoUpdatesAvailable()
* {
* // Arrange
* var localRepository = new MockSharedPackageRepository();
* var sourceRepository = new MockPackageRepository();
* var projectSystem = new MockProjectSystem();
* PackageManager packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
*
* IPackage A10 = PackageUtility.CreatePackage("A", "1.0");
* localRepository.Add(A10);
*
* // Act
* packageManager.UpdatePackage("A", updateDependencies: true, allowPrereleaseVersions: false);
*
* // Assert
* Assert.True(localRepository.Exists("A", new SemanticVersion("1.0")));
* }
*
* [Fact]
* public void InstallPackageInstallsPrereleasePackages()
* {
* // Arrange
* var localRepository = new MockSharedPackageRepository();
* 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.0-beta",
* dependencies: new[] {
* new PackageDependency("C")
* });
*
* IPackage packageC = PackageUtility.CreatePackage("C", "1.0.0");
* sourceRepository.AddPackage(packageA);
* sourceRepository.AddPackage(packageC);
*
* // Act
* packageManager.InstallPackage("A", version: null, ignoreDependencies: false, allowPrereleaseVersions: true);
*
* // Assert
* Assert.True(localRepository.Exists(packageA));
* Assert.True(localRepository.Exists(packageC));
* }
*
* [Fact]
* public void InstallPackageDisregardTargetFrameworkOfDependencies()
* {
* // Arrange
* var localRepository = new MockSharedPackageRepository();
* 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.0",
* dependencies: new[] {
* new PackageDependency("C", null)
* });
*
* IPackage packageC = PackageUtility.CreatePackage("C", "1.0.0");
* sourceRepository.AddPackage(packageA);
* sourceRepository.AddPackage(packageC);
*
* // Act
* packageManager.InstallPackage("A", version: null, ignoreDependencies: false, allowPrereleaseVersions: true);
*
* // Assert
* Assert.True(localRepository.Exists(packageA));
* Assert.True(localRepository.Exists(packageC));
* }
*
* [Fact]
* public void InstallPackageInstallsPackagesWithPrereleaseDependenciesIfFlagIsSet()
* {
* // Arrange
* var localRepository = new MockSharedPackageRepository();
* 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.0",
* dependencies: new[] {
* new PackageDependency("C")
* });
*
* IPackage packageC = PackageUtility.CreatePackage("C", "1.0.0-RC-1");
* sourceRepository.AddPackage(packageA);
* sourceRepository.AddPackage(packageC);
*
* // Act
* packageManager.InstallPackage("A", version: null, ignoreDependencies: false, allowPrereleaseVersions: true);
*
* // Assert
* Assert.True(localRepository.Exists(packageA));
* Assert.True(localRepository.Exists(packageC));
* }
*
* [Fact]
* public void InstallPackageThrowsIfDependencyIsPrereleaseAndFlagIsNotSet()
* {
* // Arrange
* var localRepository = new MockSharedPackageRepository();
* 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.0",
* dependencies: new[] {
* new PackageDependency("C")
* });
*
* IPackage packageC = PackageUtility.CreatePackage("C", "1.0.0-RC-1");
* sourceRepository.AddPackage(packageA);
* sourceRepository.AddPackage(packageC);
*
* // Act and Assert
* ExceptionAssert.Throws<InvalidOperationException>(
* () => packageManager.InstallPackage("A", version: null, ignoreDependencies: false, allowPrereleaseVersions: false),
* "Unable to resolve dependency 'C'.");
* }
*
* [Fact]
* public void InstallPackageInstallsLowerReleaseVersionIfPrereleaseFlagIsNotSet()
* {
* // Arrange
* var localRepository = new MockSharedPackageRepository();
* 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.0",
* dependencies: new[] {
* new PackageDependency("C")
* });
*
* IPackage packageC_RC = PackageUtility.CreatePackage("C", "1.0.0-RC-1");
* IPackage packageC = PackageUtility.CreatePackage("C", "0.9");
* sourceRepository.AddPackage(packageA);
* sourceRepository.AddPackage(packageC);
* sourceRepository.AddPackage(packageC_RC);
*
* // Act
* packageManager.InstallPackage("A", version: null, ignoreDependencies: false, allowPrereleaseVersions: false);
*
* // Assert
* Assert.True(localRepository.Exists(packageA));
* Assert.True(localRepository.Exists(packageC));
* } */
/* !!! Should be changed to a test using Install-Package cmdlet
* [Fact]
* public void InstallPackageConsidersAlreadyInstalledPrereleasePackagesWhenResolvingDependencies()
* {
* // Arrange
* var packageB_05 = PackageUtility.CreatePackage("B", "0.5.0");
* var packageB_10a = PackageUtility.CreatePackage("B", "1.0.0-a");
* var packageA = PackageUtility.CreatePackage("A",
* dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("[0.5.0, 2.0.0)")) });
*
* var localRepository = new MockSharedPackageRepository();
* var sourceRepository = new MockPackageRepository();
* var projectSystem = new MockProjectSystem();
* var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
* sourceRepository.AddPackage(packageA);
* sourceRepository.AddPackage(packageB_10a);
* sourceRepository.AddPackage(packageB_05);
*
* // Act
* // The allowPrereleaseVersions flag should be irrelevant since we specify a version.
* packageManager.InstallPackage("B", version: new SemanticVersion("1.0.0-a"), ignoreDependencies: false, allowPrereleaseVersions: false);
* // Verify we actually did install B.1.0.0a
* Assert.True(localRepository.Exists(packageB_10a));
*
* packageManager.InstallPackage("A");
*
* // Assert
* Assert.True(localRepository.Exists(packageA));
* Assert.True(localRepository.Exists(packageB_10a));
*
* } */
/* !!! Should be changed to a test using Install-Package cmdlet
* [Fact]
* public void InstallPackageNotifiesBatchProcessorWhenExpandingPackageFiles()
* {
* // Arrange
* var package = PackageUtility.CreatePackage("B", "0.5.0", content: new[] { "content.txt" }, assemblyReferences: new[] { "Ref.dll" });
*
* var localRepository = new MockSharedPackageRepository();
* var sourceRepository = new MockPackageRepository();
* var fileSystem = new Mock<MockFileSystem> { CallBase = true };
* var batchProcessor = fileSystem.As<IBatchProcessor<string>>();
* batchProcessor.Setup(s => s.BeginProcessing(It.IsAny<IEnumerable<string>>(), PackageAction.Install))
* .Callback((IEnumerable<string> files, PackageAction _) => Assert.Equal(new[] { @"content\content.txt", "Ref.dll" }, files))
* .Verifiable();
* batchProcessor.Setup(s => s.EndProcessing()).Verifiable();
*
* var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, localRepository);
* sourceRepository.AddPackage(package);
*
* // Act
* packageManager.InstallPackage("B");
*
* // Assert
* Assert.True(localRepository.Exists(package));
* batchProcessor.Verify();
* }
*
* [Fact]
* public void InstallPackageDoesNotPerformWalkInfoCheckWhenPassingTheFlag()
* {
* // In this test, we simulate installing a solution-level package which depends on
* // a project-level package. Under normal condition, this is disallowed by NuGet.
* // However, if passing the 'ignoreWalkInfo' parameter with value of 'true',
* // NuGet will happily accept that. Hence the installation will succeed.
* // This is used by the package restore mode.
*
* var localRepository = new MockSharedPackageRepository();
* var sourceRepository = new MockPackageRepository();
* var projectSystem = new MockProjectSystem();
* var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
*
* // A is solution-level package
* IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0",
* tools: new string[] { "init.ps1"},
* dependencies: new[] {
* new PackageDependency("C")
* });
*
* IPackage packageC = PackageUtility.CreatePackage("C", "1.0.0-RC-1", content: new string[] { "a.txt" } );
* sourceRepository.AddPackage(packageA);
* sourceRepository.AddPackage(packageC);
*
* // Act
* packageManager.InstallPackage(packageA, ignoreDependencies: false, allowPrereleaseVersions: true, ignoreWalkInfo: true);
*
* // Assert
* Assert.True(localRepository.Exists(packageA));
* Assert.True(localRepository.Exists(packageC));
* } */
private PackageManager CreatePackageManager()
{
var projectSystem = new MockProjectSystem();
return(new PackageManager(
new MockPackageRepository(),
new DefaultPackagePathResolver(projectSystem),
projectSystem,
new MockSharedPackageRepository()));
}
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") });
var projectSystem = new MockProjectSystem();
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
sourceRepository.AddPackage(runtimePackage);
sourceRepository.AddPackage(satellitePackage);
// Act
packageManager.InstallPackage("foo");
packageManager.InstallPackage("foo.ja-jp");
packageManager.UninstallPackage("foo.ja-jp");
// Assert
Assert.Equal(2, projectSystem.Paths.Count);
Assert.True(projectSystem.FileExists(@"foo.1.0.0\content\english.txt"));
Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\foo.dll"));
Assert.False(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\foo.resources.dll"));
Assert.False(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\foo.xml"));
Assert.False(projectSystem.FileExists(@"foo.ja-jp.1.0.0\content\english.txt"));
Assert.False(projectSystem.FileExists(@"foo.ja-jp.1.0.0\content\japanese.txt"));
Assert.False(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\japanese.xml"));
Assert.False(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.resources.dll"));
Assert.False(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.xml"));
Assert.False(projectSystem.FileExists(@"foo.1.0.0\lib\japanese.xml"));
Assert.False(projectSystem.FileExists(@"foo.1.0.0\content\japanese.txt"));
}
public void CreateRefreshFileAddsRefreshFileUnderBinDirectory()
{
// Arrange
var projectSystem = new MockProjectSystem(VersionUtility.DefaultTargetFramework, @"x:\test\site\");
var assemblyPath = @"x:\test\packages\Foo.1.0\lib\net40\Foo.dll";
// Act
projectSystem.CreateRefreshFile(assemblyPath);
// Assert
Assert.Equal(@"..\packages\Foo.1.0\lib\net40\Foo.dll", projectSystem.ReadAllText(@"bin\Foo.dll.refresh"));
}
public void CreateRefreshFileUsesAbsolutePathIfRelativePathsCannotBeFormed()
{
// Arrange
var projectSystem = new MockProjectSystem(VersionUtility.DefaultTargetFramework, @"z:\test\site\");
var assemblyPath = @"x:\test\packages\Foo.1.0\lib\net40\Bar.net40.dll";
// Act
projectSystem.CreateRefreshFile(assemblyPath);
// Assert
Assert.Equal(@"x:\test\packages\Foo.1.0\lib\net40\Bar.net40.dll", projectSystem.ReadAllText(@"bin\Bar.net40.dll.refresh"));
}
public void UninstallPackageRemovesDependenciesIfFlagIsTrue()
{
// Arrange
var activeRepository = new MockPackageRepository();
var localRepository = new Mock <MockPackageRepository>()
{
CallBase = true
};
localRepository.As <ISharedPackageRepository>();
var projectRepository = new MockProjectPackageRepository(localRepository.Object);
var project = TestUtils.GetProject("Foo");
var projectSystem = new MockProjectSystem();
var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository);
var packageA = PackageUtility.CreatePackage("A", dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", content: new[] { "file1.txt" });
var scriptExecutor = new Mock <IScriptExecutor>(MockBehavior.Strict);
scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", packageA, project, It.IsAny <FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable();
scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\B.1.0", "uninstall.ps1", packageB, project, It.IsAny <FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable();
var packageManager = new Mock <VsPackageManager>(
TestUtils.GetSolutionManager(),
activeRepository,
new Mock <IFileSystemProvider>().Object,
new MockFileSystem(),
localRepository.Object,
new Mock <IDeleteOnRestartManager>().Object,
new Mock <VsPackageInstallerEvents>().Object,
/* multiFrameworkTargeting */ null)
{
CallBase = true
};
projectManager.LocalRepository.AddPackage(packageA);
projectManager.LocalRepository.AddPackage(packageB);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false)).Returns(packageManager.Object);
packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable();
var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object);
// Act
localRepository.Object.AddPackage(packageA);
localRepository.Object.AddPackage(packageB);
packageUninstaller.UninstallPackage(project, "A", removeDependencies: true);
// Assert
scriptExecutor.Verify();
Assert.False(localRepository.Object.Contains(packageA));
Assert.False(localRepository.Object.Contains(packageB));
}
public void AddFilesAskingForResolutionForEveryConflict()
{
var resolutions = new FileConflictResolution[]
{
FileConflictResolution.Ignore,
FileConflictResolution.Overwrite,
FileConflictResolution.Ignore,
FileConflictResolution.IgnoreAll,
FileConflictResolution.OverwriteAll,
FileConflictResolution.Overwrite,
};
var index = 0;
var logger = new Mock <ILogger>();
logger.Setup(l => l.ResolveFileConflict(It.IsAny <string>()))
.Returns(() => resolutions[index++]);
// Arrange
var project = new MockProjectSystem();
project.AddFile("a.txt", "this is a");
project.AddFile("b.txt", "this is b");
project.AddFile("c.txt", "this is c");
project.AddFile("d.txt", "this is d");
project.AddFile("e.txt", "this is e");
project.AddFile("f.txt", "this is f");
project.Logger = logger.Object;
var files = PackageUtility.CreateFiles(new [] { "a.txt", "b.txt", "c.txt", "d.txt", "e.txt", "f.txt" }, "content");
// Act
project.AddFiles(files, new Dictionary <FileTransformExtensions, IPackageFileTransformer>());
// Assert
Assert.True(project.FileExists("a.txt"));
Assert.True(project.FileExists("b.txt"));
Assert.True(project.FileExists("c.txt"));
Assert.True(project.FileExists("d.txt"));
Assert.True(project.FileExists("e.txt"));
Assert.True(project.FileExists("f.txt"));
logger.Verify(l => l.ResolveFileConflict(It.IsAny <string>()), Times.Exactly(6));
Assert.Equal("this is a", project.ReadAllText("a.txt"));
Assert.Equal("content\\b.txt", project.ReadAllText("b.txt"));
Assert.Equal("this is c", project.ReadAllText("c.txt"));
Assert.Equal("this is d", project.ReadAllText("d.txt"));
Assert.Equal("content\\e.txt", project.ReadAllText("e.txt"));
Assert.Equal("content\\f.txt", project.ReadAllText("f.txt"));
}
public void AddPackageAddsFileToFileSystem()
{
// Arrange
var mockFileSystem = new MockProjectSystem();
var repository = new LocalPackageRepository(new DefaultPackagePathResolver(mockFileSystem),
mockFileSystem);
IPackage package = PackageUtility.CreatePackage("A", "1.0");
// Act
repository.AddPackage(package);
// Assert
Assert.True(mockFileSystem.FileExists(@"A.1.0\A.1.0.nupkg"));
}
public void UpdatePackageWithMultipleSharedDependencies()
{
// Arrange
var localRepository = new Mock <MockPackageRepository>()
{
CallBase = true
}.As <ISharedPackageRepository>();
var projectRepository = new MockProjectPackageRepository(localRepository.Object);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
// A1 -> B1, C1
// A2 -> B1
var A10 = PackageUtility.CreatePackage("A", "1.0", assemblyReferences: new[] { "A1.dll" }, dependencies: new[] {
new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")),
new PackageDependency("C", VersionUtility.ParseVersionSpec("1.0")),
});
var A20 = PackageUtility.CreatePackage("A", "2.0", assemblyReferences: new[] { "A2.dll" }, dependencies: new[] {
new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0"))
});
var B10 = PackageUtility.CreatePackage("B", "1.0", assemblyReferences: new[] { "B1.dll" });
var C10 = PackageUtility.CreatePackage("C", "1.0", assemblyReferences: new[] { "C1.dll" });
sourceRepository.AddPackage(A10);
sourceRepository.AddPackage(A20);
sourceRepository.AddPackage(B10);
sourceRepository.AddPackage(C10);
localRepository.Object.AddPackage(A10);
localRepository.Object.AddPackage(A20);
localRepository.Object.AddPackage(B10);
localRepository.Object.AddPackage(C10);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock <IRecentPackageRepository>().Object);
var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository);
projectManager.AddPackageReference("A", new Version("1.0"));
// Act
packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, logger: NullLogger.Instance);
// Assert
Assert.IsFalse(packageManager.LocalRepository.Exists(A10));
Assert.IsFalse(projectSystem.ReferenceExists("A1.dll"));
Assert.IsFalse(packageManager.LocalRepository.Exists(C10));
Assert.IsFalse(projectSystem.ReferenceExists("C1.dll"));
Assert.IsTrue(packageManager.LocalRepository.Exists(B10));
Assert.IsTrue(projectSystem.ReferenceExists("B1.dll"));
Assert.IsTrue(packageManager.LocalRepository.Exists(A20));
Assert.IsTrue(projectSystem.ReferenceExists("A2.dll"));
}
public void AddFilesAddFilesToProjectSystem()
{
// Arrange
var fileSystem = new MockProjectSystem();
var files = PackageUtility.CreateFiles(new[] { "A", "B", "C" });
// Act
fileSystem.AddFiles(files, String.Empty);
// Assert
Assert.True(fileSystem.FileExists("A"));
Assert.True(fileSystem.FileExists("B"));
Assert.True(fileSystem.FileExists("C"));
}
