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 InstallCommandUpdatesPackageIfAlreadyPresentAndNotUsingSideBySide()
{
// Arrange
var fileSystem = new MockFileSystem();
var repository = new MockPackageRepository();
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager)
{
Console = new MockConsole(),
ExcludeVersion = true,
Version = "0.4",
};
installCommand.Arguments.Add("Baz");
// Act - 1
installCommand.ExecuteCommand();
// Assert - 1
Assert.True(repository.Exists("Baz", new SemanticVersion("0.4")));
// Act - 2
installCommand.Version = null;
installCommand.Execute();
// Assert - 2
Assert.False(repository.Exists("Baz", new SemanticVersion("0.4")));
Assert.True(repository.Exists("Baz", new SemanticVersion("0.7")));
}
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 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 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 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 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 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 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 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 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 void EnsurePackageDownloadsThePackageIfItIsNotCachedInMemoryOnInMachineCache()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>()))
.Returns(zipPackage)
.Verifiable();
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
var mockRepository = new MockPackageRepository();
var context = new Mock <IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny <object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = "NEWHASH",
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
Context = context.Object
};
// Act
servicePackage.EnsurePackage(mockRepository);
// Assert
context.Verify();
packageDownloader.Verify();
Assert.True(mockRepository.Exists(zipPackage));
}
public void InstallPackageNotifiesBatchProcessorWhenExpandingPackageFiles()
{
// Arrange
var package = PackageUtility.CreatePackage("B", "0.5.0", content: new[] { "content.txt" }, assemblyReferences: new[] { "Ref.dll" });
var localRepository = new MockPackageRepository();
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();
}
public void UpdatePackageUninstallsPackageAndInstallsNewPackage()
{
// Arrange
var localRepository = new MockPackageRepository();
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");
IPackage A20 = PackageUtility.CreatePackage("A", "2.0");
localRepository.Add(A10);
sourceRepository.Add(A20);
// Act
packageManager.UpdatePackage("A", updateDependencies: true);
// Assert
Assert.IsFalse(localRepository.Exists("A", new Version("1.0")));
Assert.IsTrue(localRepository.Exists("A", new Version("2.0")));
}
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 UpdatePackageDoesNothingIfNoUpdatesAvailable()
{
// Arrange
var localRepository = new MockPackageRepository();
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);
// Assert
Assert.IsTrue(localRepository.Exists("A", new Version("1.0")));
}
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 void AddPackageReferenceAddingPackageWithDuplicateReferenceOverwritesReference()
{
// Arrange
var projectSystem = new MockProjectSystem();
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
assemblyReferences: new[] { "reference.dll" });
var packageB = PackageUtility.CreatePackage("B", "1.0",
assemblyReferences: new[] { "reference.dll" });
mockRepository.AddPackage(packageA);
mockRepository.AddPackage(packageB);
// Act
projectManager.AddPackageReference("A");
projectManager.AddPackageReference("B");
// Assert
Assert.Equal(0, projectSystem.Paths.Count);
Assert.Equal(1, projectSystem.References.Count);
Assert.True(projectSystem.References.ContainsKey(@"reference.dll"));
Assert.True(projectSystem.References.ContainsValue(@"MockFileSystem\B.1.0\reference.dll"));
Assert.True(localRepository.Exists("A"));
Assert.True(localRepository.Exists("B"));
}
public void AddPackageReferenceAddsContentAndReferencesProjectSystem()
{
// Arrange
var projectSystem = new MockProjectSystem();
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "contentFile" },
new[] { "reference.dll" },
new[] { "tool" });
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.Equal(1, projectSystem.Paths.Count);
Assert.Equal(1, projectSystem.References.Count);
Assert.True(projectSystem.References.ContainsKey(@"reference.dll"));
Assert.True(projectSystem.FileExists(@"contentFile"));
Assert.True(localRepository.Exists("A"));
}
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 void AddPackageReferenceAddsContentAccordingToTargetFramework3()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("2.0")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "sl3\\contentFile", "winrt45\\jQuery.js" },
new[] { "lib\\reference.dll" });
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.Equal(0, projectSystem.Paths.Count);
Assert.True(localRepository.Exists("A"));
}
public void AddPackageReferenceAllowsAddingMetadataPackage()
{
// Arrange
var projectSystem = new MockProjectSystem();
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0", new [] { "hello.txt" });
var packageB = PackageUtility.CreatePackage("B", "2.0", dependencies: new[] { new PackageDependency("A") });
var mockPackageB = Mock.Get(packageB);
var files = PackageUtility.CreateFiles(new[] { "readme.txt", "foo.bar" });
mockPackageB.Setup(p => p.GetFiles()).Returns(files);
mockRepository.AddPackage(packageA);
mockRepository.AddPackage(packageB);
// Act
projectManager.AddPackageReference("B");
// Assert
Assert.True(localRepository.Exists("A"));
Assert.True(localRepository.Exists("B"));
}
public void AddPackageReferenceWithAnyNonCompatibleReferenceThrowsAndPackageIsNotReferenced()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object, localRepository);
mockProjectSystem.Setup(m => m.TargetFramework).Returns(new FrameworkName(".NETFramework", new Version("2.0")));
var mockPackage = new Mock<IPackage>();
mockPackage.Setup(m => m.Id).Returns("A");
mockPackage.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
mockPackage.Setup(m => m.Listed).Returns(true);
var assemblyReference = PackageUtility.CreateAssemblyReference("foo.dll", new FrameworkName(".NETFramework", new Version("5.0")));
mockPackage.Setup(m => m.AssemblyReferences).Returns(new[] { assemblyReference });
sourceRepository.AddPackage(mockPackage.Object);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(
() => projectManager.AddPackageReference("A"),
"Could not install package 'A 1.0'. You are trying to install this package into a project that targets '.NETFramework,Version=v2.0', but the package does not contain any assembly references or content files that are compatible with that framework. For more information, contact the package author.");
Assert.False(localRepository.Exists(mockPackage.Object));
}
public void AddPackageAskToResolveConflictForEveryFileWithDependency()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var localRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
projectSystem.AddFile("one.txt", "this is one");
projectSystem.AddFile("two.txt", "this is two");
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
IPackage packageA = PackageUtility.CreatePackage(
"A", "1.0", content: new[] { "one.txt" }, dependencies: new PackageDependency[] { new PackageDependency("B") });
sourceRepository.AddPackage(packageA);
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "two.txt" });
sourceRepository.AddPackage(packageB);
var logger = new Mock<ILogger>();
logger.Setup(l => l.ResolveFileConflict(It.IsAny<string>())).Returns(FileConflictResolution.OverwriteAll);
projectManager.Logger = projectSystem.Logger = logger.Object;
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(localRepository.Exists("A"));
Assert.Equal("content\\one.txt", projectSystem.ReadAllText("one.txt"));
Assert.Equal("content\\two.txt", projectSystem.ReadAllText("two.txt"));
logger.Verify(l => l.ResolveFileConflict(It.IsAny<string>()), Times.Exactly(2));
}
public void AddPackageReferenceAcceptsMetaPackage()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.0")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new [] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0-alpha", new [] { "net\\hello.txt" });
mockRepository.AddPackage(packageA);
mockRepository.AddPackage(packageB);
// Act
projectManager.AddPackageReference("A", version: null, ignoreDependencies: false, allowPrereleaseVersions: true);
// Assert
Assert.True(localRepository.Exists("A"));
Assert.True(localRepository.Exists("B"));
}
public void AddPackageReferenceRecognizeEmptyFrameworkFolder2()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName("Silverlight", new Version("4.0")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "sl20\\contentFile", "sl20\\sub\\no.txt", "sl3\\_._", "foo.css" },
new[] { "reference.dll" });
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.Equal(0, projectSystem.Paths.Count);
Assert.False(projectSystem.FileExists(@"_._"));
Assert.True(localRepository.Exists("A"));
}
public void AddPackageReferenceThrowsIfThereIsNoCompatibleFrameworkFolderUnderContentAndLib()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.0")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
content: new[] { "silverlight\\reference.txt" },
assemblyReferences: new string[] { "lib\\windows8\\one.dll" });
mockRepository.AddPackage(packageA);
// Act
ExceptionAssert.Throws<InvalidOperationException>(() => projectManager.AddPackageReference("A"));
// Assert
Assert.False(localRepository.Exists("A"));
}
public void ExecuteMethodCallsUninstallPackageMethodOnPackageManager()
{
// 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(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
projectManager1.Setup(p => p.IsInstalled(It.IsAny <IPackage>())).Returns <IPackage>(p => localRepository.Exists(p));
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
projectManager2.Setup(p => p.IsInstalled(It.IsAny <IPackage>())).Returns <IPackage>(p => localRepository.Exists(p));
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(Enumerable.Empty <Project>());
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.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.UninstallPackage(
projectManager1.Object,
packageB.Id,
null,
false,
false,
provider),
Times.Once());
packageManager.Verify(p => p.UninstallPackage(
projectManager2.Object,
packageB.Id,
null,
false,
false,
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 ExecuteMethodCallsUninstallPackageMethodOnPackageManager()
{
// 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(packageB);
var projectManager1 = new Mock<IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
projectManager1.Setup(p => p.IsInstalled(It.IsAny<IPackage>())).Returns<IPackage>(p => localRepository.Exists(p));
var projectManager2 = new Mock<IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
projectManager2.Setup(p => p.IsInstalled(It.IsAny<IPackage>())).Returns<IPackage>(p => localRepository.Exists(p));
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(Enumerable.Empty<Project>());
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.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.UninstallPackage(
projectManager1.Object,
packageB.Id,
null,
false,
false,
provider),
Times.Once());
packageManager.Verify(p => p.UninstallPackage(
projectManager2.Object,
packageB.Id,
null,
false,
false,
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 AddPackageWithUnsupportedTransformFileSkipsUnsupportedFile()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var localRepository = new MockPackageRepository();
var projectSystem = new Mock<MockProjectSystem>() { CallBase = true };
projectSystem.Setup(m => m.IsSupportedFile("unsupported")).Returns(false);
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem.Object), projectSystem.Object, localRepository);
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { "a", "b", "unsupported.pp" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.Equal(2, projectSystem.Object.Paths.Count);
Assert.True(projectSystem.Object.FileExists("a"));
Assert.True(projectSystem.Object.FileExists("b"));
Assert.True(localRepository.Exists("A"));
Assert.False(projectSystem.Object.FileExists("unsupported"));
}
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 AddPackageDoNotTransformPackagesConfigFileInNestedFolder()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var localRepository = new MockPackageRepository();
var projectSystem = new Mock<MockProjectSystem>() { CallBase = true };
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem.Object), projectSystem.Object, localRepository);
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { "a", "b", "sub\\packages.config.pp", "local\\PACKAGES.config.transform", "fod\\packages.config.Install.XDT", "car\\Packages.Config.uninstall.Xdt" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.Equal(6, projectSystem.Object.Paths.Count);
Assert.True(projectSystem.Object.FileExists("a"));
Assert.True(projectSystem.Object.FileExists("b"));
Assert.True(projectSystem.Object.FileExists("sub\\packages.config.pp"));
Assert.True(projectSystem.Object.FileExists("local\\packages.config.transform"));
Assert.True(projectSystem.Object.FileExists("fod\\packages.config.install.xdt"));
Assert.True(projectSystem.Object.FileExists("car\\packages.config.uninstall.xdt"));
Assert.True(localRepository.Exists("A"));
Assert.False(projectSystem.Object.FileExists("sub\\packages.config"));
Assert.False(projectSystem.Object.FileExists("local\\packages.config"));
}
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 RemovePackageWithTransformFileThatThrowsContinuesRemovingPackage()
{
// Arrange
var mockProjectSystem = new MockProjectSystem();
var mockRepository = new MockPackageRepository();
var localRepository = new MockPackageRepository();
mockProjectSystem.AddFile("web.config", () => { throw new UnauthorizedAccessException(); });
mockProjectSystem.AddFile("foo.txt");
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(new MockProjectSystem()), mockProjectSystem, localRepository);
var package = new Mock<IPackage>();
package.Setup(m => m.Id).Returns("A");
package.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
var file = new Mock<IPackageFile>();
var contentFile = new Mock<IPackageFile>();
contentFile.Setup(m => m.Path).Returns(@"content\foo.txt");
contentFile.Setup(m => m.GetStream()).Returns(new MemoryStream());
contentFile.Setup(m => m.EffectivePath).Returns("foo.txt");
file.Setup(m => m.Path).Returns(@"content\web.config.transform");
file.Setup(m => m.EffectivePath).Returns("web.config.transform");
file.Setup(m => m.GetStream()).Returns(() =>
@"<configuration>
<system.web>
<compilation debug=""true"" targetFramework=""4.0"" />
</system.web>
</configuration>
".AsStream());
package.Setup(m => m.GetFiles()).Returns(new[] { file.Object, contentFile.Object });
mockRepository.AddPackage(package.Object);
projectManager.LocalRepository.AddPackage(package.Object);
// Act
projectManager.RemovePackageReference("A");
// Assert
Assert.False(mockProjectSystem.FileExists("foo.txt"));
Assert.False(localRepository.Exists(package.Object));
}
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 AddPackageReferenceWithAnyNonCompatibleFrameworkReferenceDoesThrow()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object, localRepository);
mockProjectSystem.Setup(m => m.TargetFramework).Returns(VersionUtility.ParseFrameworkName("net20"));
var mockPackage = new Mock<IPackage>();
mockPackage.Setup(m => m.Id).Returns("A");
mockPackage.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
mockPackage.Setup(m => m.Listed).Returns(true);
var frameworkReference = new FrameworkAssemblyReference("System.Web", new[] { VersionUtility.ParseFrameworkName("net50") });
mockPackage.Setup(m => m.FrameworkAssemblies).Returns(new[] { frameworkReference });
sourceRepository.AddPackage(mockPackage.Object);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(
() => projectManager.AddPackageReference("A"));
Assert.False(localRepository.Exists(mockPackage.Object));
}
public void InstallPackageNotifiesBatchProcessorWhenExpandingPackageFiles()
{
// Arrange
var package = PackageUtility.CreatePackage("B", "0.5.0", content: new[] { "content.txt" }, assemblyReferences: new[] { "Ref.dll" });
var localRepository = new MockPackageRepository();
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[] { PathFixUtility.FixPath(@"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();
}
public void AddPackageReferenceDoesNotImportsTargetOrPropFileThatAreNotAtContentRoot()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName("Native", new Version("2.0")), "x:\\root");
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0");
var mockPackageA = Mock.Get(packageA);
var files = PackageUtility.CreateFiles(new[] { "build\\native\\foo\\A.targets", "build\\native\\bar\\B.props", "content\\native\\foo.css" });
mockPackageA.Setup(p => p.GetFiles()).Returns(files);
mockRepository.AddPackage(mockPackageA.Object);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(localRepository.Exists("A"));
Assert.False(projectSystem.ImportExists("x:\\root\\A.1.0\\build\\native\\foo\\A.targets"));
Assert.False(projectSystem.ImportExists("x:\\root\\A.1.0\\build\\native\\bar\\A.props"));
}
public void UpdatePackageOverwriteAllFilesWhenFileConflictActionSetToOverwrite()
{
// 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 console = new Mock<IConsole>();
console.Setup(c => c.ResolveFileConflict(It.IsAny<string>())).Returns(FileConflictResolution.Ignore);
var updateCommand = new UpdateCommand()
{
RepositoryFactory = repositoryFactory.Object,
SourceProvider = packageSourceProvider.Object,
Console = console.Object,
FileConflictAction = FileConflictAction.Overwrite
};
// 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("content\\two.txt", projectSystem.ReadAllText("two.txt"));
}
public void RemovePackageReferenceRemoveContentAccordingToTargetFramework()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("2.0")));
projectSystem.AddFile("jQuery.js", "content\\[net35]\\jQuery.js");
projectSystem.AddFile("foo.css", "content\\foo.css");
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "net20\\contentFile", "net35\\jQuery.js", "foo.css" },
new[] { "lib\\eference.dll" });
mockRepository.AddPackage(packageA);
projectManager.AddPackageReference("A");
Assert.True(projectSystem.FileExists(@"contentFile"));
// Act
projectManager.RemovePackageReference("A");
// Assert
Assert.Equal(2, projectSystem.Paths.Count);
Assert.True(projectSystem.FileExists(@"jQuery.js"));
Assert.True(projectSystem.FileExists(@"foo.css"));
Assert.False(localRepository.Exists("A"));
}
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 AddPackageReferenceDoesNotThrowIfThereIsCompatibleAssemblyInContentButNotInLib()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.0")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
content: new[] { "net20\\reference.txt" },
assemblyReferences: new string[] { "lib\\WindowsPhone7\\one.dll" });
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(localRepository.Exists("A"));
Assert.False(projectSystem.ReferenceExists("one.dll"));
Assert.True(projectSystem.FileExists("reference.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.True(localRepository.Exists(packageA));
Assert.True(localRepository.Exists(packageB));
Assert.True(localRepository.Exists(packageC));
}
public void AddPackageReferenceAddsAssemblyReferencesUsingNewFolderConvention()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.0")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "contentFiles" },
new[] { "lib\\net35\\reference.dll", "lib\\net45\\bar.dll" });
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.Equal(1, projectSystem.References.Count);
Assert.True(projectSystem.References.ContainsKey(@"reference.dll"));
Assert.False(projectSystem.References.ContainsKey(@"bar.dll"));
Assert.True(localRepository.Exists("A"));
}
public void UpdatePackageDoesNothingIfNoUpdatesAvailable()
{
// Arrange
var localRepository = new MockPackageRepository();
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")));
}
public void AddPackageReferenceRecognizeEmptyFrameworkFolder5()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETCore", new Version("4.5")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
assemblyReferences: new string[] {
"lib\\sl3\\reference.dll",
"lib\\winrt\\_._",
"lib\\winrt45\\one.dll"
});
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.ReferenceExists("reference.dll"));
Assert.False(projectSystem.ReferenceExists("_._"));
Assert.True(projectSystem.ReferenceExists("one.dll"));
Assert.True(localRepository.Exists("A"));
}
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);
}
