public void AddPackageWithXdtTransformFile()
{
// Arrange
var mockProjectSystem = new MockProjectSystem();
var mockRepository = new MockPackageRepository();
mockProjectSystem.AddFile("web.config",
@"<configuration>
<system.web>
<compilation debug=""true"" />
</system.web>
</configuration>
".AsStream());
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(new MockProjectSystem()), mockProjectSystem, new MockPackageRepository());
var package = new Mock<IPackage>();
package.Setup(m => m.Id).Returns("A");
package.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
package.Setup(m => m.Listed).Returns(true);
var file = new Mock<IPackageFile>();
file.Setup(m => m.Path).Returns(@"content\web.config.install.xdt");
file.Setup(m => m.EffectivePath).Returns("web.config.install.xdt");
file.Setup(m => m.GetStream()).Returns(() =>
@"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform"">
<system.web>
<compilation xdt:Locator=""Condition('@debug=true')"" debug=""false"" xdt:Transform=""Replace"" />
</system.web>
</configuration>".AsStream());
var file2 = new Mock<IPackageFile>();
file2.Setup(m => m.Path).Returns(@"content\web.config.uninstall.xdt");
file2.Setup(m => m.EffectivePath).Returns("web.config.uninstall.xdt");
file2.Setup(m => m.GetStream()).Returns(() =>
@"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform"">
<system.web>
<compilation xdt:Locator=""Match(debug)"" debug=""false"" xdt:Transform=""Remove"" />
</system.web>
</configuration>".AsStream());
package.Setup(m => m.GetFiles()).Returns(new[] { file.Object, file2.Object });
mockRepository.AddPackage(package.Object);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(mockProjectSystem.FileExists("web.config.install.xdt"));
Assert.False(mockProjectSystem.FileExists("web.config.uninstall.xdt"));
Assert.True(mockProjectSystem.FileExists("web.config"));
Assert.Equal(
@"<configuration>
<system.web>
<compilation debug=""false""/>
</system.web>
</configuration>
", mockProjectSystem.OpenFile("web.config").ReadToEnd());
}
public void 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"));
}
public void AddingPackageReferenceAddsPreprocessedFileToTargetPathWithRemovedExtension()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { @"foo\bar\file.pp" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.FileExists(@"foo\bar\file.pp"));
Assert.True(projectSystem.FileExists(@"foo\bar\file"));
}
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.IsTrue(mockFileSystem.FileExists(@"A.1.0\A.1.0.nupkg"));
}
public void RemovingPackageWithModifiedContentFileWithinIgnoreMarkersSucceeds2()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var projectManager = new ProjectManager(
sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var packageA = PackageUtility.CreatePackage("A", "1.0", content: new[] { "a.file" });
var contentFile = PackageUtility.CreateMockedPackageFile("content", "a.file", @"this is awesome.
*******NUGET: BEGIN LICENSE TEXT------------------
SDAFLKDSAJFL;KJDSAL;KFJL;DSAKJFL;KDSA
******NUGET: END LICENSE TEXT-------");
var mockPackageA = Mock.Get<IPackage>(packageA);
mockPackageA.Setup(p => p.GetFiles()).Returns(new[] { contentFile.Object });
sourceRepository.AddPackage(packageA);
projectManager.AddPackageReference("A");
Assert.True(projectManager.LocalRepository.Exists(packageA));
Assert.True(projectSystem.FileExists("a.file"));
projectSystem.ReadAllText("a.file");
// now modify 'a.file' to include ignore line markers
projectSystem.AddFile("a.file", @"this is awesome.");
// Act
projectManager.RemovePackageReference("A");
// Assert
Assert.False(projectManager.LocalRepository.Exists(packageA));
Assert.False(projectSystem.FileExists("a.file"));
}
public void AddPackageReferencePicksThePortableLibraryWithMoreMatchingVersionsWhenInstalledIntoPortableProject2()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(VersionUtility.ParseFrameworkName("portable-net45+sl5+wp71"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
new[] { "portable-net45+sl5+wp8\\one.txt",
"portable-net45+sl5+wp8\\two.txt",
"portable-net45+sl5+wp71+win8\\three.txt",
"portable-net45+sl4+wp71+win8\\four.txt",
"portable-net40+sl4+wp71+win8\\five.txt",
"portable-net40+sl4+wp7+win8\\six.txt",
"portable-wp8+win8\\seven.txt" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.FileExists("one.txt"));
Assert.False(projectSystem.FileExists("two.txt"));
Assert.True(projectSystem.FileExists("three.txt"));
Assert.False(projectSystem.FileExists("four.txt"));
Assert.False(projectSystem.FileExists("five.txt"));
Assert.False(projectSystem.FileExists("six.txt"));
Assert.False(projectSystem.FileExists("seven.txt"));
}
public void AddPackageReferencePicksMatchingProfileEvenIfItIsEmpty()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(VersionUtility.ParseFrameworkName("sl4"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { "sl3\\_._", "me.txt" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.FileExists("me.txt"));
Assert.False(projectSystem.FileExists("_._"));
}
public void AddPackageReferencePrefersFullProfileOverClientProfileWhenInstallIntoFullProfileProject()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
content: new[] { "net40-client\\b.txt", "net40\\a.txt" },
assemblyReferences: new[] { "lib\\net40\\a.dll", "lib\\net40-client\\b.dll" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.ReferenceExists("b.dll"));
Assert.False(projectSystem.FileExists("b.txt"));
Assert.True(projectSystem.ReferenceExists("a.dll"));
Assert.True(projectSystem.FileExists("a.txt"));
}
public void AddPackageReferencePickPortableDependencySetOverFallbackDependencySet()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(VersionUtility.ParseFrameworkName("portable-net45+wp8+windows8"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var dependencySets = new PackageDependencySet[]
{
new PackageDependencySet(targetFramework: null, dependencies: new [] { PackageDependency.CreateDependency("B", "1.0.0")}),
new PackageDependencySet(targetFramework: VersionUtility.ParseFrameworkName("net45"), dependencies: new PackageDependency[0] { }),
new PackageDependencySet(targetFramework: VersionUtility.ParseFrameworkName("win8"), dependencies: new PackageDependency[0] { }),
new PackageDependencySet(targetFramework: VersionUtility.ParseFrameworkName("wp8"), dependencies: new PackageDependency[0] { }),
new PackageDependencySet(targetFramework: VersionUtility.ParseFrameworkName("portable-net45+win8+wp8"), dependencies: new PackageDependency[0] { }),
};
IPackage packageA = PackageUtility.CreatePackageWithDependencySets("A", "1.0", new[] { "me.txt" }, dependencySets: dependencySets);
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", new[] { "you.txt" });
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
// Act
projectManager.AddPackageReference("A", null, ignoreDependencies: false, allowPrereleaseVersions: true);
// Assert
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.False(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("me.txt"));
Assert.False(projectSystem.FileExists("you.txt"));
}
public void UpdatePackageReferenceIncludeDependencyPackageCorrectly2()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.0")));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var dependency = new PackageDependency("B", null);
var dependencySet = CreateDependencySet(".NETFramework, Version=4.0", dependency);
IPackage packageA = PackageUtility.CreatePackageWithDependencySets("A", "1.0",
dependencySets: new List<PackageDependencySet> { dependencySet },
content: new[] { "a.txt" });
var dependency2 = new PackageDependency("B", null);
var dependencySet2 = CreateDependencySet(".NETFramework, Version=4.5", dependency2);
IPackage packageA2 = PackageUtility.CreatePackageWithDependencySets("A", "2.0",
dependencySets: new List<PackageDependencySet> { dependencySet2 },
content: new[] { "a2.txt" });
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "b.txt" });
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageA2);
projectManager.AddPackageReference("A", new SemanticVersion("1.0"));
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.True(projectManager.LocalRepository.Exists("B"));
// Act
projectManager.UpdatePackageReference("A");
// Assert
Assert.False(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.0")));
Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("2.0")));
Assert.False(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("a2.txt"));
Assert.False(projectSystem.FileExists("b.txt"));
}
public void RemovePackageReferenceExcludesFileIfAnotherPackageUsesThem()
{
// Arrange
var mockProjectSystem = new MockProjectSystem();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(new MockProjectSystem()), mockProjectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "fileA", "commonFile" });
IPackage packageB = PackageUtility.CreatePackage("B", "1.0",
new[] { "fileB", "commonFile" });
mockRepository.AddPackage(packageA);
mockRepository.AddPackage(packageB);
projectManager.AddPackageReference("A");
projectManager.AddPackageReference("B");
// Act
projectManager.RemovePackageReference("A");
// Assert
Assert.True(mockProjectSystem.Deleted.Contains(@"fileA"));
Assert.True(mockProjectSystem.FileExists(@"commonFile"));
}
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 ReinstallPackagesRestoresPackageInAllProjectsWithNewContentIfSourcePackageChanges()
{
// Arrange
var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var localRepository = localRepositoryMock.Object;
var sourceRepository = new MockPackageRepository();
var projectSystem1 = new MockProjectSystem();
var pathResolver1 = new DefaultPackagePathResolver(projectSystem1);
var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository);
var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1);
var projectSystem2 = new MockProjectSystem();
var pathResolver2 = new DefaultPackagePathResolver(projectSystem2);
var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository);
var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2);
var project1 = TestUtils.GetProject("Project1");
var project2 = TestUtils.GetProject("Project2");
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(projects: new[] { project1, project2 }),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem2,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project1, projectManager1);
packageManager.RegisterProjectManager(project2, projectManager2);
var packageA = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "content.txt" },
new[] { "lib\\ref.dll" });
var packageA2 = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "foo.txt" },
new[] { "lib\\bar.dll" });
var packageB = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "hello.txt" },
new[] { "lib\\comma.dll" });
var packageB2 = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "world.txt" },
new[] { "lib\\dude.dll" });
sourceRepository.Add(packageA);
sourceRepository.Add(packageB);
// install package A -> project 1
// and package B -> project 2
packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectSystem2.FileExists("hello.txt"));
Assert.True(projectSystem2.ReferenceExists("comma.dll"));
// now change the package A and B to different packages
sourceRepository.RemovePackage(packageA);
sourceRepository.RemovePackage(packageB);
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageB2);
localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version));
localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version));
// Act
packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance, eventListener: NullPackageOperationEventListener.Instance);
// Assert
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.False(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.FileExists("foo.txt"));
Assert.False(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(projectSystem1.ReferenceExists("bar.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.False(projectSystem2.FileExists("hello.txt"));
Assert.True(projectSystem2.FileExists("world.txt"));
Assert.False(projectSystem2.ReferenceExists("comma.dll"));
Assert.True(projectSystem2.ReferenceExists("dude.dll"));
}
public void ReinstallPackagesSkipRestallingForOneProjectButProceedWithTheOther()
{
// Arrange
var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var localRepository = localRepositoryMock.Object;
var sourceRepository = new MockPackageRepository();
var projectSystem1 = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0"));
var pathResolver1 = new DefaultPackagePathResolver(projectSystem1);
var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository);
var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1);
var projectSystem2 = new MockProjectSystem(new FrameworkName(".NETCore, Version=v4.5"));
var pathResolver2 = new DefaultPackagePathResolver(projectSystem2);
var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository);
var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2);
var project1 = TestUtils.GetProject("Project1");
var project2 = TestUtils.GetProject("Project2");
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(projects: new[] { project1, project2 }),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem2,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project1, projectManager1);
packageManager.RegisterProjectManager(project2, projectManager2);
var packageA = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "net30\\content.txt", "silverlight40\\content4.txt" },
new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" });
var packageB = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "winrt45\\hello.txt", "sl4-wp71\\world.txt" },
new[] { "lib\\winrt45\\comma.dll", "lib\\sl4-wp71\\dude.dll" });
sourceRepository.Add(packageA);
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
// install package A -> project 1
// and package B -> project 2
packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
// now change project's target framework to silverlight
projectSystem1.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0"));
projectSystem2.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0, Profile=WindowsPhone71"));
localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version));
localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version));
var logger = new Mock<ILogger>();
logger.Setup(s => s.Log(
MessageLevel.Warning,
"Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.",
"B 2.0",
"Project2")
).Verifiable();
// Act
packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: logger.Object, eventListener: NullPackageOperationEventListener.Instance);
// Assert
logger.Verify();
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.False(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.FileExists("content4.txt"));
Assert.False(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(projectSystem1.ReferenceExists("refsl.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectSystem2.FileExists("hello.txt"));
Assert.False(projectSystem2.FileExists("world.txt"));
Assert.True(projectSystem2.ReferenceExists("comma.dll"));
Assert.False(projectSystem2.ReferenceExists("dude.dll"));
}
public void ReinstallPackagesRestoresAllPackagesInAProjectWithNewContentIfProjectFrameworkChanges()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0"));
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageReferenceRepository = new PackageReferenceRepository(projectSystem, localRepository);
var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, packageReferenceRepository);
var packageManager = new VsPackageManager(
TestUtils.GetSolutionManager(),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
var packageA = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "net30\\content.txt", "silverlight40\\content4.txt" },
new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" });
var packageB = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "net30\\contentB.txt", "silverlight40\\content4B.txt" },
new[] { "lib\\net30\\refB.dll", "lib\\silverlight40\\refslB.dll" });
sourceRepository.Add(packageA);
sourceRepository.Add(packageB);
packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
packageManager.InstallPackage(projectManager, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectSystem.FileExists("content.txt"));
Assert.False(projectSystem.FileExists("content4.txt"));
Assert.True(projectSystem.ReferenceExists("ref.dll"));
Assert.False(projectSystem.ReferenceExists("refsl.dll"));
Assert.True(packageManager.LocalRepository.Exists("B"));
Assert.True(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("contentB.txt"));
Assert.False(projectSystem.FileExists("content4B.txt"));
Assert.True(projectSystem.ReferenceExists("refB.dll"));
Assert.False(projectSystem.ReferenceExists("refslB.dll"));
// now change project's target framework to silverlight
projectSystem.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0"));
// Act
packageManager.ReinstallPackages(projectManager, updateDependencies: true, allowPrereleaseVersions: false, logger: null);
// Assert
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.False(projectSystem.FileExists("content.txt"));
Assert.True(projectSystem.FileExists("content4.txt"));
Assert.False(projectSystem.ReferenceExists("ref.dll"));
Assert.True(projectSystem.ReferenceExists("refsl.dll"));
Assert.True(packageManager.LocalRepository.Exists("B"));
Assert.True(projectManager.LocalRepository.Exists("B"));
Assert.False(projectSystem.FileExists("contentB.txt"));
Assert.True(projectSystem.FileExists("content4B.txt"));
Assert.False(projectSystem.ReferenceExists("refB.dll"));
Assert.True(projectSystem.ReferenceExists("refslB.dll"));
}
public void AddPackageReferenceDoNotIncludeDependencyPackageIfTargetFrameworkDoesNotMatch(string dependencyVersion)
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("2.0")));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var dependency = new PackageDependency("B", null);
var dependencySet = new PackageDependencySet(
new FrameworkName(".NETFramework", new Version(dependencyVersion)),
new PackageDependency[] {dependency});
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", content: new[] { "a.txt" });
Mock.Get(packageA).Setup(p => p.DependencySets).Returns(new [] {dependencySet});
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "b.txt" });
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.False(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("a.txt"));
Assert.False(projectSystem.FileExists("b.txt"));
}
public void RemovePackageReferenceRemoveDependencyPackageCorrectly2()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("2.0")));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var dependencyB = new PackageDependency("B", null);
var dependencySetB = CreateDependencySet(".NETFramework, Version=2.1", dependencyB);
var dependencyC = new PackageDependency("C", null);
var dependencySetC = CreateDependencySet(".NETFramework, Version=2.0", dependencyC);
IPackage packageA = PackageUtility.CreatePackageWithDependencySets("A", "1.0",
dependencySets: new List<PackageDependencySet> { dependencySetB, dependencySetC },
content: new[] { "a.txt" });
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "b.txt" });
IPackage packageC = PackageUtility.CreatePackage("C", "2.0", content: new[] { "c.txt" });
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
projectManager.AddPackageReference("A");
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.False(projectManager.LocalRepository.Exists("B"));
Assert.True(projectManager.LocalRepository.Exists("C"));
Assert.True(projectSystem.FileExists("a.txt"));
Assert.False(projectSystem.FileExists("b.txt"));
Assert.True(projectSystem.FileExists("c.txt"));
// Act
projectManager.RemovePackageReference("A", forceRemove: false, removeDependencies: true);
Assert.False(projectManager.LocalRepository.Exists("A"));
Assert.False(projectManager.LocalRepository.Exists("B"));
Assert.False(projectManager.LocalRepository.Exists("C"));
Assert.False(projectSystem.FileExists("a.txt"));
Assert.False(projectSystem.FileExists("b.txt"));
Assert.False(projectSystem.FileExists("c.txt"));
}
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 AddPackageReferencePicksPortableLibraryFilesOverFallbackFiles()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(VersionUtility.ParseFrameworkName("portable-sl4+net4+wp8+windows8"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { "portable-windows8+sl4+wp8+net4\\portable.txt", "me.txt" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.FileExists("me.txt"));
Assert.True(projectSystem.FileExists("portable.txt"));
}
public void AddPackageReferenceImportsTargetOrPropFileAtContentRoot()
{
// 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\\A.targets", "build\\a.props", "content\\foo.css" });
mockPackageA.Setup(p => p.GetFiles()).Returns(files);
mockRepository.AddPackage(mockPackageA.Object);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(localRepository.Exists("A"));
Assert.Equal(1, projectSystem.Paths.Count);
Assert.True(projectSystem.FileExists(@"foo.css"));
Assert.False(projectSystem.FileExists(@"a.targets"));
Assert.False(projectSystem.FileExists(@"A.props"));
Assert.True(projectSystem.ImportExists("x:\\root\\A.1.0\\build\\A.props", ProjectImportLocation.Top));
Assert.True(projectSystem.ImportExists("x:\\root\\A.1.0\\build\\A.targets", ProjectImportLocation.Bottom));
}
public void AddPackageReferencePicksSpecificLibraryOverPortableOne(string pickedContentFile, string projectFramework)
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(projectFramework));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { "portable40-net40+wp7+silverlight4+windows\\two.txt", pickedContentFile});
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.FileExists("two.txt"));
Assert.True(projectSystem.FileExists("one.txt"));
}
public void AddPackageReferenceAddsContentAccordingToTargetFramework2()
{
// 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", "sub\\foo.css" },
new[] { "lib\\reference.dll" });
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.Equal(1, projectSystem.Paths.Count);
Assert.True(projectSystem.FileExists(@"sub\foo.css"));
Assert.True(localRepository.Exists("A"));
}
public void AddPackageReferencePrefersVersionClosenessOverClientProfileCompatibility()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5, Profile=Client"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
content: new[] { "net35\\a.txt", "net4.0.0.1\\b.txt", "net40-client\\c.txt", "net4.5.0.1-client\\d.txt" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.FileExists("a.txt"));
Assert.True(projectSystem.FileExists("b.txt"));
Assert.False(projectSystem.FileExists("c.txt"));
Assert.False(projectSystem.FileExists("d.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 AddPackageReferencePicksThePortableLibraryWithHigherVersionOfTheMatchingFrameworks(string contentFile, string otherContentFile)
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName("Silverlight, Version=4.0"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { contentFile, otherContentFile });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(projectSystem.FileExists("one.txt"));
Assert.False(projectSystem.FileExists("two.txt"));
}
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 AddPackageReferencePicksThePortableLibraryWithLeastPlatformsWhenInstalledIntoNonPortableProject()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(VersionUtility.ParseFrameworkName("netcore45"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
new[] { "portable-net45+sl4+win8+wp8\\zero.txt",
"portable-net45+win8+wp8\\one.txt",
"portable-net40+sl4+win8+wp71\\two.txt"});
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.FileExists("zero.txt"));
Assert.True(projectSystem.FileExists("one.txt"));
Assert.False(projectSystem.FileExists("two.txt"));
}
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 RemovingPackageWithModifiedContentFileWithinBeginMarkersRemoveFile()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var projectManager = new ProjectManager(
sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var packageA = PackageUtility.CreatePackage("A", "1.0", content: new[] { "a.file" });
sourceRepository.AddPackage(packageA);
projectManager.AddPackageReference("A");
Assert.True(projectManager.LocalRepository.Exists(packageA));
Assert.True(projectSystem.FileExists("a.file"));
projectSystem.ReadAllText("a.file");
// now modify 'a.file' to include ignore line markers
projectSystem.AddFile("a.file", @"content\a.file
-----------------NUGET: BEGIN LICENSE TEXT
dsaflkdjsal;fkjdsal;kjf
sdafkljdsal;kjfl;dkasjfl;kdas
fdsalk;fj;lkdsajfl;kdsa");
// Act
projectManager.RemovePackageReference("A");
// Assert
Assert.False(projectManager.LocalRepository.Exists(packageA));
Assert.False(projectSystem.FileExists("a.file"));
}
public void AddPackageReferenceIncludeDependencyPackageCorrectly(string dependencyVersion)
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.0")));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var dependency = new PackageDependency("B", null);
var dependecySets = CreateDependencySet(".NETFramework, Version=" + dependencyVersion, dependency);
IPackage packageA = PackageUtility.CreatePackageWithDependencySets("A", "1.0",
dependencySets: new [] { dependecySets },
content: new[] { "a.txt" });
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "b.txt" });
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.True(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("a.txt"));
Assert.True(projectSystem.FileExists("b.txt"));
}