public void TestMetadataSerDe()
{
using var tempDir = new TemporaryDirectory();
var metadata = new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[] { "/assembly/probe/path" },
NativeProbingPaths = new string[] { "/native/probe/path" },
NuGets = new DependencyProviderUtils.NuGetMetadata[]
{
new DependencyProviderUtils.NuGetMetadata
{
FileName = "package.name.1.0.0.nupkg",
PackageName = "package.name",
PackageVersion = "1.0.0"
}
}
};
string serializedFilePath = Path.Combine(tempDir.Path, "serializedMetadata");
metadata.Serialize(serializedFilePath);
DependencyProviderUtils.Metadata deserializedMetadata =
DependencyProviderUtils.Metadata.Deserialize(serializedFilePath);
Assert.True(metadata.Equals(deserializedMetadata));
}
internal DependencyProvider(string metadataFilePath, string srcPath, string dstPath)
{
DependencyProviderUtils.Metadata metadata =
DependencyProviderUtils.Metadata.Deserialize(metadataFilePath);
string unpackPath = Path.Combine(dstPath, ".nuget", "packages");
Directory.CreateDirectory(unpackPath);
UnpackPackages(srcPath, unpackPath, metadata.NuGets);
_dependencyProvider = CreateDependencyProvider(unpackPath, metadata);
}
public void TestsUnpackPackages()
{
string packageFileName = "package.name.1.0.0.nupkg";
string packageName = "package.name";
string packageVersion = "1.0.0";
using var emptyFileDir = new TemporaryDirectory();
string emptyFileName = "emptyfile";
File.Create(Path.Combine(emptyFileDir.Path, emptyFileName)).Dispose();
using var nupkgDir = new TemporaryDirectory();
ZipFile.CreateFromDirectory(
emptyFileDir.Path,
Path.Combine(nupkgDir.Path, packageFileName));
var metadata = new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[] { "/assembly/probe/path" },
NativeProbingPaths = new string[] { "/native/probe/path" },
NuGets = new DependencyProviderUtils.NuGetMetadata[]
{
new DependencyProviderUtils.NuGetMetadata
{
FileName = packageFileName,
PackageName = packageName,
PackageVersion = packageVersion
}
}
};
using var unpackDir = new TemporaryDirectory();
string metadataFilePath =
Path.Combine(nupkgDir.Path, DependencyProviderUtils.CreateFileName(1));
metadata.Serialize(metadataFilePath);
// Files located in nupkgDir
// nuget: package.name.1.0.0.nupkg
// metadata file: dependencyProviderMetadata_00000000000000000001
var dependencyProvider =
new DependencyProvider(metadataFilePath, nupkgDir.Path, unpackDir.Path);
string expectedPackagePath =
Path.Combine(unpackDir.Path, ".nuget", "packages", packageName, packageVersion);
string expectedFilePath = Path.Combine(expectedPackagePath, emptyFileName);
Assert.True(File.Exists(expectedFilePath));
}
public void TestMetadataEquals()
{
string expectedAssemblyProbingPath = "/assembly/probe/path";
string expectedNativeProbingPath = "/native/probe/path";
var expectedNugetMetadata = new DependencyProviderUtils.NuGetMetadata
{
FileName = "package.name.1.0.0.nupkg",
PackageName = "package.name",
PackageVersion = "1.0.0"
};
var metadata = new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath },
NativeProbingPaths = new string[] { expectedNativeProbingPath },
NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata }
};
Assert.False(metadata.Equals(null));
Assert.False(metadata.Equals(new DependencyProviderUtils.Metadata()));
Assert.False(metadata.Equals(new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath },
NativeProbingPaths = new string[] { expectedNativeProbingPath, "" },
NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata }
}));
Assert.False(metadata.Equals(new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath },
NativeProbingPaths = new string[] { expectedNativeProbingPath },
NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata, null }
}));
Assert.False(metadata.Equals(new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath, "" },
NativeProbingPaths = new string[] { expectedNativeProbingPath },
NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata }
}));
Assert.True(metadata.Equals(new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath },
NativeProbingPaths = new string[] { expectedNativeProbingPath },
NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata }
}));
}
private DepManager.DependencyProvider CreateDependencyProvider(
string basePath,
DependencyProviderUtils.Metadata metadata)
{
IEnumerable <string> AssemblyProbingPaths()
{
foreach (string dependency in metadata.AssemblyProbingPaths)
{
yield return(Path.Combine(basePath, dependency));
}
}
IEnumerable <string> NativeProbingRoots()
{
foreach (string dependency in metadata.NativeProbingPaths)
{
yield return(Path.Combine(basePath, dependency));
}
}
return(new DepManager.DependencyProvider(
AssemblyProbingPaths,
NativeProbingRoots));
}
public void TestPackageResolver()
{
using var tempDir = new TemporaryDirectory();
string packageName = "package.name";
string packageVersion = "0.1.0";
string packageRootPath =
Path.Combine(tempDir.Path, "path", "to", "packages", packageName, packageVersion);
string packageFrameworkPath = Path.Combine(packageRootPath, "lib", "framework");
Directory.CreateDirectory(packageRootPath);
var nugetFile = new FileInfo(
Path.Combine(packageRootPath, $"{packageName}.{packageVersion}.nupkg"));
using (File.Create(nugetFile.FullName))
{
}
var assemblyPaths = new List <FileInfo>
{
new FileInfo(Path.Combine(packageFrameworkPath, "1.dll")),
new FileInfo(Path.Combine(packageFrameworkPath, "2.dll"))
};
var probingPaths = new List <DirectoryInfo> {
new DirectoryInfo(packageRootPath)
};
var mockPackageRestoreContextWrapper = new Mock <PackageRestoreContextWrapper>();
mockPackageRestoreContextWrapper
.SetupGet(m => m.ResolvedPackageReferences)
.Returns(new ResolvedPackageReference[]
{
new ResolvedPackageReference(
packageName,
packageVersion,
assemblyPaths,
new DirectoryInfo(packageRootPath),
probingPaths)
});
var packageResolver = new PackageResolver(mockPackageRestoreContextWrapper.Object);
IEnumerable <string> actualFiles = packageResolver.GetFiles(tempDir.Path);
string metadataFilePath =
Path.Combine(tempDir.Path, DependencyProviderUtils.CreateFileName(1));
var expectedFiles = new string[]
{
nugetFile.FullName,
metadataFilePath
};
Assert.True(expectedFiles.SequenceEqual(actualFiles));
Assert.True(File.Exists(metadataFilePath));
DependencyProviderUtils.Metadata actualMetadata =
DependencyProviderUtils.Metadata.Deserialize(metadataFilePath);
var expectedMetadata = new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[]
{
Path.Combine(packageName, packageVersion, "lib", "framework", "1.dll"),
Path.Combine(packageName, packageVersion, "lib", "framework", "2.dll")
},
NativeProbingPaths = new string[]
{
Path.Combine(packageName, packageVersion)
},
NuGets = new DependencyProviderUtils.NuGetMetadata[]
{
new DependencyProviderUtils.NuGetMetadata
{
FileName = $"{packageName}.{packageVersion}.nupkg",
PackageName = packageName,
PackageVersion = packageVersion
}
}
};
Assert.True(expectedMetadata.Equals(actualMetadata));
}
