public void GetPackages_ReturnsAllPackagesInsideDirectory()
{
// Arrange
var fooPackage = new PackageBuilder
{
Id = "Foo",
Version = new SemanticVersion("1.0.0"),
Description = "Some description",
};
fooPackage.Authors.Add("test author");
fooPackage.Files.Add(
PackageUtility.CreateMockedPackageFile(@"lib\net40", "Foo.dll", "lib contents").Object);
var barPackage = new PackageBuilder
{
Id = "Bar",
Version = new SemanticVersion("1.0.0-beta1"),
Description = "Some description",
};
barPackage.Authors.Add("test author");
barPackage.Files.Add(
PackageUtility.CreateMockedPackageFile("", "README.md", "lib contents").Object);
barPackage.Files.Add(
PackageUtility.CreateMockedPackageFile(@"content", "qwerty.js", "bar contents").Object);
barPackage.Files.Add(
PackageUtility.CreateMockedPackageFile(@"lib\net451", "test.dll", "test-dll").Object);
var fileSystem = new MockFileSystem();
var fooRoot = Path.Combine("Foo", "1.0.0");
fileSystem.AddFile(Path.Combine(fooRoot, "Foo.nuspec"),
@"<?xml version=""1.0""?><package><metadata><id>Foo</id><version>1.0.0</version><authors>None</authors><description>None</description></metadata></package>");
fileSystem.AddFile(Path.Combine("Foo", "1.0.0", "Foo.1.0.0.nupkg.sha512"), "Foo-sha");
fileSystem.AddFile(Path.Combine("Foo", "1.0.0", "Foo.1.0.0.nupkg"), GetPackageStream(fooPackage));
var barRoot = Path.Combine("Bar", "1.0.0-beta1");
fileSystem.AddFile(Path.Combine(barRoot, "Bar.nuspec"),
@"<?xml version=""1.0""?><package><metadata><id>Bar</id><version>1.0.0.0-beta1</version><authors>None</authors><description>None</description></metadata></package>");
fileSystem.AddFile(Path.Combine("Bar", "1.0.0-beta1", "Bar.1.0.0-beta1.nupkg.sha512"), "bar-sha");
fileSystem.AddFile(Path.Combine("Bar", "1.0.0-beta1", "Bar.1.0.0-beta1.nupkg"), GetPackageStream(barPackage));
var repository = new ExpandedPackageRepository(fileSystem);
// Act
var packages = repository.GetPackages().ToList();
// Assert
Assert.Equal(2, packages.Count);
var package = packages[0];
Assert.Equal("Foo", package.Id);
Assert.Equal(new SemanticVersion("1.0.0"), package.Version);
var packageFile = Assert.Single(package.GetFiles());
Assert.Equal(@"lib\net40\Foo.dll", packageFile.Path);
Assert.Equal(".NETFramework,Version=v4.0", packageFile.TargetFramework.FullName);
package = packages[1];
Assert.Equal("Bar", package.Id);
Assert.Equal(new SemanticVersion("1.0.0-beta1"), package.Version);
var files = package.GetFiles().OrderBy(p => p.Path.Length).ToList();
Assert.Equal(3, files.Count);
Assert.Equal(@"README.md", files[0].Path);
packageFile = files[1];
Assert.Equal(@"content\qwerty.js", packageFile.Path);
Assert.Null(packageFile.TargetFramework);
packageFile = files[2];
Assert.Equal(@"lib\net451\test.dll", packageFile.Path);
Assert.Equal(".NETFramework,Version=v4.5.1", packageFile.TargetFramework.FullName);
}
public void EnsurePackageDownloadsPackageIfCacheIsInvalid()
{
// Arrange
byte[] hashBytes1 = new byte[] { 1, 2, 3, 4 };
byte[] hashBytes2 = new byte[] { 3, 4, 5, 6 };
string hash1 = Convert.ToBase64String(hashBytes1);
string hash2 = Convert.ToBase64String(hashBytes2);
var zipPackage1 = PackageUtility.CreatePackage("A", "1.2");
var zipPackage2 = PackageUtility.CreatePackage("B", "1.2");
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny <Stream>())).Returns(hashBytes1);
var mockRepository = new Mock <IPackageCacheRepository>(MockBehavior.Strict);
var lookup = mockRepository.As <IPackageLookup>();
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
lookup.Setup(s => s.Exists("A", new SemanticVersion("1.2")))
.Returns(true);
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>(), It.IsAny <Stream>()))
.Callback(() =>
{
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage2);
})
.Verifiable();
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 = hash1,
PackageHashAlgorithm = "SHA512",
HashProvider = hashProvider.Object,
Downloader = packageDownloader.Object,
Context = context.Object
};
mockRepository.Setup(s => s.InvokeOnPackage("A", new SemanticVersion("1.2"), It.IsAny <Action <Stream> >()))
.Callback(() =>
{
using (var stream = new MemoryStream())
{
packageDownloader.Object.DownloadPackage(servicePackage.DownloadUrl, servicePackage, stream);
}
})
.Returns(true);
// Act 1
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 1
Assert.Equal(zipPackage1, servicePackage._package);
context.Verify(c => c.GetReadStreamUri(It.IsAny <object>()), Times.Never());
// Act 2
servicePackage.PackageHash = hash2;
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 2
Assert.Equal(zipPackage2, servicePackage._package);
context.Verify();
packageDownloader.Verify();
}
public void UninstallingSatellitePackageRemovesFilesFromRuntimePackageFolder()
{
// Arrange
// Create a runtime package and a satellite package that has a dependency on the runtime package, and uses the
// local suffix convention.
var runtimePackage = PackageUtility.CreatePackage("foo", "1.0.0",
assemblyReferences: new[] {
@"lib\foo.dll"
},
content: new[] {
@"english.txt"
});
var satellitePackage = PackageUtility.CreatePackage(
"foo.ja-jp", "1.0.0", language: "ja-jp",
satelliteAssemblies: new[] {
@"lib\ja-jp\foo.resources.dll",
@"lib\ja-jp\foo.xml",
@"lib\japanese.xml"
},
content: new[] {
@"english.txt",
@"japanese.txt"
},
dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.0]")) });
var packagesFolder = new MockFileSystem(@"c:\packagesFolder");
var sharedRepository = new MockSharedPackageRepository2();
var sourceRepository = new MockPackageRepository();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(packagesFolder), packagesFolder, sharedRepository);
sourceRepository.AddPackage(runtimePackage);
sourceRepository.AddPackage(satellitePackage);
var projectSystem = new MockProjectSystem();
var projectLocalRepo = new PackageReferenceRepository(
new MockFileSystem(@"c:\project"),
"projectName",
sharedRepository);
var projectManager = new ProjectManager(
packageManager,
packageManager.PathResolver,
projectSystem,
projectLocalRepo);
// Act
Install("foo", projectManager);
Install("foo.ja-jp", projectManager);
Uninstall("foo.ja-jp", packageManager, projectManager);
// Assert
Assert.Equal(2, packagesFolder.Paths.Count);
Assert.True(packagesFolder.FileExists(@"foo.1.0.0\content\english.txt"));
Assert.True(packagesFolder.FileExists(@"foo.1.0.0\lib\foo.dll"));
Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\ja-jp\foo.resources.dll"));
Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\ja-jp\foo.xml"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\content\english.txt"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\content\japanese.txt"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\japanese.xml"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.resources.dll"));
Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.xml"));
Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\japanese.xml"));
Assert.False(packagesFolder.FileExists(@"foo.1.0.0\content\japanese.txt"));
}
private static IEnumerable <IPackage> GetPackagesWithException()
{
yield return(PackageUtility.CreatePackage("A"));
throw new InvalidOperationException();
}
public void ResolveDependenciesForInstallSameDependencyAtDifferentLevelsInGraphDuringUpdate()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A1 -> B1, C1
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
content: new[] { "A1" },
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "1.0"),
PackageDependency.CreateDependency("C", "1.0")
});
// B1
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", new[] { "B1" });
// C1 -> B1, D1
IPackage packageC = PackageUtility.CreatePackage("C", "1.0",
content: new[] { "C1" },
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "1.0"),
PackageDependency.CreateDependency("D", "1.0")
});
// D1 -> B1
IPackage packageD = PackageUtility.CreatePackage("D", "1.0",
content: new[] { "A1" },
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "1.0")
});
// A2 -> B2, C2
IPackage packageA2 = PackageUtility.CreatePackage("A", "2.0",
content: new[] { "A2" },
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "2.0"),
PackageDependency.CreateDependency("C", "2.0")
});
// B2
IPackage packageB2 = PackageUtility.CreatePackage("B", "2.0", new[] { "B2" });
// C2 -> B2, D2
IPackage packageC2 = PackageUtility.CreatePackage("C", "2.0",
content: new[] { "C2" },
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "2.0"),
PackageDependency.CreateDependency("D", "2.0")
});
// D2 -> B2
IPackage packageD2 = PackageUtility.CreatePackage("D", "2.0",
content: new[] { "D2" },
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "2.0")
});
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD);
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageB2);
sourceRepository.AddPackage(packageC2);
sourceRepository.AddPackage(packageD2);
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
localRepository.AddPackage(packageC);
localRepository.AddPackage(packageD);
IPackageOperationResolver resolver = new ProjectInstallWalker(localRepository,
sourceRepository,
new DependentsWalker(localRepository),
NullLogger.Instance,
ignoreDependencies: false);
var operations = resolver.ResolveOperations(packageA2).ToList();
Assert.AreEqual(8, operations.Count);
AssertOperation("A", "1.0", PackageAction.Uninstall, operations[0]);
AssertOperation("C", "1.0", PackageAction.Uninstall, operations[1]);
AssertOperation("D", "1.0", PackageAction.Uninstall, operations[2]);
AssertOperation("B", "1.0", PackageAction.Uninstall, operations[3]);
AssertOperation("B", "2.0", PackageAction.Install, operations[4]);
AssertOperation("D", "2.0", PackageAction.Install, operations[5]);
AssertOperation("C", "2.0", PackageAction.Install, operations[6]);
AssertOperation("A", "2.0", PackageAction.Install, operations[7]);
}
public void ResolveDependenciesForInstallDiamondDependencyGraphWithDifferntVersionOfSamePackage()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A -> [B, C]
// B -> [D >= 1, E >= 2]
// C -> [D >= 2, E >= 1]
// A
// / \
// B C
// | \ | \
// D1 E2 D2 E1
IPackage packageA = PackageUtility.CreateProjectLevelPackage("A", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("B"),
new PackageDependency("C")
});
IPackage packageB = PackageUtility.CreateProjectLevelPackage("B", "1.0",
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("D", "1.0"),
PackageDependency.CreateDependency("E", "2.0")
});
IPackage packageC = PackageUtility.CreateProjectLevelPackage("C", "1.0",
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("D", "2.0"),
PackageDependency.CreateDependency("E", "1.0")
});
IPackage packageD10 = PackageUtility.CreateProjectLevelPackage("D", "1.0");
IPackage packageD20 = PackageUtility.CreateProjectLevelPackage("D", "2.0");
IPackage packageE10 = PackageUtility.CreateProjectLevelPackage("E", "1.0");
IPackage packageE20 = PackageUtility.CreateProjectLevelPackage("E", "2.0");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD20);
sourceRepository.AddPackage(packageD10);
sourceRepository.AddPackage(packageE20);
sourceRepository.AddPackage(packageE10);
IPackageOperationResolver projectResolver = new ProjectInstallWalker(localRepository,
sourceRepository,
new DependentsWalker(localRepository),
NullLogger.Instance,
ignoreDependencies: false);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false);
// Act
var operations = resolver.ResolveOperations(packageA).ToList();
var projectOperations = resolver.ResolveOperations(packageA).ToList();
// Assert
Assert.AreEqual(5, operations.Count);
Assert.AreEqual("E", operations[0].Package.Id);
Assert.AreEqual(new Version("2.0"), operations[0].Package.Version);
Assert.AreEqual("B", operations[1].Package.Id);
Assert.AreEqual("D", operations[2].Package.Id);
Assert.AreEqual(new Version("2.0"), operations[2].Package.Version);
Assert.AreEqual("C", operations[3].Package.Id);
Assert.AreEqual("A", operations[4].Package.Id);
Assert.AreEqual(5, projectOperations.Count);
Assert.AreEqual("E", projectOperations[0].Package.Id);
Assert.AreEqual(new Version("2.0"), projectOperations[0].Package.Version);
Assert.AreEqual("B", projectOperations[1].Package.Id);
Assert.AreEqual("D", projectOperations[2].Package.Id);
Assert.AreEqual(new Version("2.0"), projectOperations[2].Package.Version);
Assert.AreEqual("C", projectOperations[3].Package.Id);
Assert.AreEqual("A", projectOperations[4].Package.Id);
}
