public void ItComputesExcludeFromPublishList()
{
LockFile lockFile = TestLockFiles.GetLockFile("dependencies.withgraphs");
ProjectContext projectContext = lockFile.CreateProjectContext(
FrameworkConstants.CommonFrameworks.NetStandard16,
runtime: null,
Constants.DefaultPlatformLibrary,
runtimeFrameworks: null,
isSelfContained: false);
IEnumerable <string> excludeFromPublishPackageIds = new[] { "Microsoft.Extensions.Logging.Abstractions" };
IDictionary <string, LockFileTargetLibrary> libraryLookup =
projectContext
.LockFileTarget
.Libraries
.ToDictionary(e => e.Name, StringComparer.OrdinalIgnoreCase);
HashSet <string> exclusionList =
projectContext.GetExcludeFromPublishList(excludeFromPublishPackageIds, libraryLookup);
HashSet <string> expectedExclusions = new HashSet <string>()
{
"Microsoft.Extensions.Logging.Abstractions",
"System.Collections.Concurrent",
"System.Diagnostics.Tracing",
};
exclusionList.Should().BeEquivalentTo(expectedExclusions);
}
private DependencyContext BuildDependencyContextWithReferenceAssemblies(bool useCompilationOptions)
{
string mainProjectName = "simple.dependencies";
LockFile lockFile = TestLockFiles.GetLockFile(mainProjectName);
SingleProjectInfo mainProject = SingleProjectInfo.Create(
"/usr/Path",
mainProjectName,
".dll",
"1.0.0",
new ITaskItem[] { });
ITaskItem[] referencePaths = new ITaskItem[]
{
new MockTaskItem(
"/usr/Path/System.NotConflicting.dll",
new Dictionary <string, string>
{
{ "CopyLocal", "false" },
{ "FusionName", "System.NotConflicting, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null" },
{ "Version", "" },
}),
new MockTaskItem(
"/usr/Path/System.Collections.NonGeneric.dll",
new Dictionary <string, string>
{
{ "CopyLocal", "false" },
{ "FusionName", "System.Collections.NonGeneric, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null" },
{ "Version", "" },
}),
new MockTaskItem(
"/usr/Path/System.Collections.NonGeneric.Reference.dll",
new Dictionary <string, string>
{
{ "CopyLocal", "false" },
{ "FusionName", "System.Collections.NonGeneric.Reference, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null" },
{ "Version", "" },
}),
};
ProjectContext projectContext = lockFile.CreateProjectContext(
FrameworkConstants.CommonFrameworks.NetCoreApp10,
runtime: null,
platformLibraryName: Constants.DefaultPlatformLibrary,
isSelfContained: false);
CompilationOptions compilationOptions =
useCompilationOptions ? CreateCompilationOptions() :
null;
DependencyContext dependencyContext = new DependencyContextBuilder(mainProject, projectContext, includeRuntimeFileVersions: false)
.WithReferenceAssemblies(ReferenceInfo.CreateReferenceInfos(referencePaths))
.WithCompilationOptions(compilationOptions)
.Build();
// ensure the DependencyContext can be written out successfully - it has no duplicate dependency names
Save(dependencyContext);
return(dependencyContext);
}
public void ItBuildsDependencyContextsFromProjectLockFiles(
string mainProjectName,
string mainProjectVersion,
CompilationOptions compilationOptions,
string baselineFileName,
string runtime,
ITaskItem[] assemblySatelliteAssemblies,
ITaskItem[] referencePaths,
ITaskItem[] referenceSatellitePaths)
{
LockFile lockFile = TestLockFiles.GetLockFile(mainProjectName);
SingleProjectInfo mainProject = SingleProjectInfo.Create(
"/usr/Path",
mainProjectName,
".dll",
mainProjectVersion,
assemblySatelliteAssemblies ?? new ITaskItem[] { });
IEnumerable <ReferenceInfo> directReferences =
ReferenceInfo.CreateDirectReferenceInfos(
referencePaths ?? new ITaskItem[] { },
referenceSatellitePaths ?? new ITaskItem[] { });
ProjectContext projectContext = lockFile.CreateProjectContext(
FrameworkConstants.CommonFrameworks.NetCoreApp10,
runtime,
Constants.DefaultPlatformLibrary,
runtimeFrameworks: null,
isSelfContained: !string.IsNullOrEmpty(runtime));
DependencyContext dependencyContext = new DependencyContextBuilder(mainProject, projectContext, includeRuntimeFileVersions: false)
.WithDirectReferences(directReferences)
.WithCompilationOptions(compilationOptions)
.Build();
JObject result = Save(dependencyContext);
JObject baseline = ReadJson($"{baselineFileName}.deps.json");
try
{
baseline
.Should()
.BeEquivalentTo(result);
}
catch
{
// write the result file out on failure for easy comparison
using (JsonTextWriter writer = new JsonTextWriter(File.CreateText($"result-{baselineFileName}.deps.json")))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Formatting = Formatting.Indented;
serializer.Serialize(writer, result);
}
throw;
}
}
public void ItCanGenerateTheRuntimeFallbackGraph()
{
string mainProjectName = "simple.dependencies";
LockFile lockFile = TestLockFiles.GetLockFile(mainProjectName);
SingleProjectInfo mainProject = SingleProjectInfo.Create(
"/usr/Path",
mainProjectName,
".dll",
"1.0.0",
new ITaskItem[] { });
ProjectContext projectContext = lockFile.CreateProjectContext(
FrameworkConstants.CommonFrameworks.NetCoreApp10.GetShortFolderName(),
runtime: null,
platformLibraryName: Constants.DefaultPlatformLibrary,
runtimeFrameworks: null,
isSelfContained: true);
var runtimeGraph = new RuntimeGraph(
new RuntimeDescription []
{
new RuntimeDescription("os-arch", new string [] { "os", "base" }),
new RuntimeDescription("new_os-arch", new string [] { "os-arch", "os", "base" }),
new RuntimeDescription("os-new_arch", new string [] { "os-arch", "os", "base" }),
new RuntimeDescription("new_os-new_arch", new string [] { "new_os-arch", "os-new_arch", "os-arch", "os", "base" }),
new RuntimeDescription("os-another_arch", new string [] { "os", "base" })
});
void CheckRuntimeFallbacks(string runtimeIdentifier, int fallbackCount)
{
projectContext.LockFileTarget.RuntimeIdentifier = runtimeIdentifier;
var dependencyContextBuilder = new DependencyContextBuilder(mainProject, includeRuntimeFileVersions: false, runtimeGraph, projectContext);
var runtimeFallbacks = dependencyContextBuilder.Build().RuntimeGraph;
runtimeFallbacks
.Count()
.Should()
.Be(fallbackCount);
runtimeFallbacks
.Any(runtimeFallback => !runtimeFallback.Runtime.Equals(runtimeIdentifier) && !runtimeFallback.Fallbacks.Contains(runtimeIdentifier))
.Should()
.BeFalse();
}
CheckRuntimeFallbacks("os-arch", 4);
CheckRuntimeFallbacks("new_os-arch", 2);
CheckRuntimeFallbacks("os-new_arch", 2);
CheckRuntimeFallbacks("new_os-new_arch", 1);
CheckRuntimeFallbacks("unrelated_os-unknown_arch", 0);
}
public void ItResolvesAssembliesFromProjectLockFiles(string projectName, string runtime, object[] expectedResolvedFiles)
{
LockFile lockFile = TestLockFiles.GetLockFile(projectName);
ProjectContext projectContext = lockFile.CreateProjectContext(
FrameworkConstants.CommonFrameworks.NetCoreApp10,
runtime,
Constants.DefaultPlatformLibrary);
IEnumerable <ResolvedFile> resolvedFiles = new PublishAssembliesResolver(new MockPackageResolver())
.Resolve(projectContext);
resolvedFiles
.Should()
.BeEquivalentTo(expectedResolvedFiles);
}
public void ItResolvesAssembliesFromProjectLockFilesWithStoreLayout(string projectName, string runtime, object[] expectedResolvedFiles)
{
LockFile lockFile = TestLockFiles.GetLockFile(projectName);
ProjectContext projectContext = lockFile.CreateProjectContext(
FrameworkConstants.CommonFrameworks.NetCoreApp10,
runtime,
Constants.DefaultPlatformLibrary,
runtimeFrameworks: null,
isSelfContained: false);
IEnumerable <ResolvedFile> resolvedFiles = new AssetsFileResolver(new MockPackageResolver())
.WithPreserveStoreLayout(true)
.Resolve(projectContext);
resolvedFiles
.Should()
.BeEquivalentTo(expectedResolvedFiles);
}
private static ResolvePackageDependencies GetExecutedTaskFromContents(string lockFileContents, out LockFile lockFile, bool emitLegacyAssetsFileItems = true, string target = null)
{
lockFile = TestLockFiles.CreateLockFile(lockFileContents);
return(GetExecutedTask(lockFile, emitLegacyAssetsFileItems, target));
}
private static ResolvePackageDependencies GetExecutedTaskFromPrefix(string lockFilePrefix, out LockFile lockFile, bool emitLegacyAssetsFileItems = true, string target = null)
{
lockFile = TestLockFiles.GetLockFile(lockFilePrefix);
return(GetExecutedTask(lockFile, emitLegacyAssetsFileItems, target));
}
public void ItFiltersAnalyzersByProjectLanguage()
{
string projectLanguage = "C#";
// expected included analyzers
string[] expectIncluded = new string[] {
"analyzers/dotnet/IncludedAlpha.dll",
"analyzers/dotnet/cs/IncludedBeta.dll",
"analyzers/dotnet/cs/vb/IncludedChi.dll",
};
// expected excluded files
string[] expectExcluded = new string[] {
"analyzers/dotnet/vb/ExcludedAlpha.dll",
"analyzers/dotnet/ExcludedBeta.txt",
"analyzers/dotnet/cs/ExcludedChi.txt",
"dotnet/ExcludedDelta.dll",
"dotnet/cs/ExcludedEpsilon.dll"
};
var libCFiles = new List <string>()
{
"lib/file/G.dll", "lib/file/H.dll", "lib/file/I.dll"
};
libCFiles.AddRange(expectIncluded);
libCFiles.AddRange(expectExcluded);
string libCDefn = CreateLibrary("LibC/1.2.3", "package", libCFiles.ToArray());
string lockFileContent = CreateLockFileSnippet(
targets: new string[] {
CreateTarget(".NETCoreApp,Version=v1.0", TargetLibA, TargetLibB, TargetLibC),
CreateTarget(".NETCoreApp,Version=v1.0/osx.10.11-x64", TargetLibB, TargetLibC),
},
libraries: new string[] {
LibADefn, LibBDefn, libCDefn
},
projectFileDependencyGroups: new string[] { ProjectGroup, NETCoreGroup, NETCoreOsxGroup }
);
LockFile lockFile = TestLockFiles.CreateLockFile(lockFileContent);
var task = new ResolvePackageDependencies(lockFile, new MockPackageResolver())
{
ProjectAssetsFile = lockFile.Path,
ProjectPath = null,
ProjectLanguage = projectLanguage, // set language
EmitLegacyAssetsFileItems = true
};
task.Execute().Should().BeTrue();
IEnumerable <ITaskItem> fileDefns;
fileDefns = task.FileDefinitions
.Where(t => t.GetMetadata(MetadataKeys.Type) == "AnalyzerAssembly");
fileDefns.Count().Should().Be(3);
var expectedTargets = new string[] {
"netcoreapp1.0",
"netcoreapp1.0/osx.10.11-x64"
};
foreach (var analyzer in expectIncluded)
{
var fileKey = $"LibC/1.2.3/{analyzer}";
var item = task.FileDefinitions.Where(t => t.ItemSpec == fileKey).First();
item.GetMetadata(MetadataKeys.Type).Should().Be("AnalyzerAssembly");
item.GetMetadata(MetadataKeys.Path).Should().Be(analyzer);
// expect two file dependencies for each, one per target
var fileDeps = task.FileDependencies.Where(t => t.ItemSpec == fileKey);
fileDeps.Count().Should().Be(2);
fileDeps.Select(f => f.GetMetadata(MetadataKeys.ParentTarget))
.Should().Contain(expectedTargets);
fileDeps.All(f => f.GetMetadata(MetadataKeys.ParentPackage) == "LibC/1.2.3");
}
foreach (var otherFile in expectExcluded)
{
var fileKey = $"LibC/1.2.3/{otherFile}";
var item = task.FileDefinitions.Where(t => t.ItemSpec == fileKey).First();
item.GetMetadata(MetadataKeys.Type).Should().NotBe("AnalyzerAssembly");
// expect no file dependencies for each
task.FileDependencies.Where(t => t.ItemSpec == fileKey)
.Should().BeEmpty();
}
}
public void ItAddsAnalyzerMetadataAndFileDependencies()
{
string projectLanguage = "VB";
string libCDefn = CreateLibrary("LibC/1.2.3", "package",
"lib/file/G.dll", "lib/file/H.dll", "lib/file/I.dll",
"analyzers/dotnet/cs/Microsoft.CodeAnalysis.Analyzers.dll",
"analyzers/dotnet/cs/Microsoft.CodeAnalysis.CSharp.Analyzers.dll",
"analyzers/dotnet/vb/Microsoft.CodeAnalysis.Analyzers.dll",
"analyzers/dotnet/vb/Microsoft.CodeAnalysis.VisualBasic.Analyzers.dll",
"analyzers/dotnet/cs/Microsoft.CodeAnalysis.CSharp.Analyzers.txt", // not analyzer
"lib/file/Microsoft.CodeAnalysis.VisualBasic.Analyzers.dll" // not analyzer
);
string lockFileContent = CreateLockFileSnippet(
targets: new string[] {
CreateTarget(".NETCoreApp,Version=v1.0", TargetLibA, TargetLibB, TargetLibC),
CreateTarget(".NETCoreApp,Version=v1.0/osx.10.11-x64", TargetLibB, TargetLibC),
},
libraries: new string[] {
LibADefn, LibBDefn, libCDefn
},
projectFileDependencyGroups: new string[] { ProjectGroup, NETCoreGroup, NETCoreOsxGroup }
);
LockFile lockFile = TestLockFiles.CreateLockFile(lockFileContent);
var task = new ResolvePackageDependencies(lockFile, new MockPackageResolver())
{
ProjectAssetsFile = lockFile.Path,
ProjectPath = null,
ProjectLanguage = projectLanguage, // set language
EmitLegacyAssetsFileItems = true
};
task.Execute().Should().BeTrue();
IEnumerable <ITaskItem> fileDefns;
fileDefns = task.FileDefinitions
.Where(t => t.GetMetadata(MetadataKeys.Type) == "AnalyzerAssembly");
fileDefns.Count().Should().Be(2);
var analyzers = new string[] {
"analyzers/dotnet/vb/Microsoft.CodeAnalysis.Analyzers.dll",
"analyzers/dotnet/vb/Microsoft.CodeAnalysis.VisualBasic.Analyzers.dll",
};
var expectedTargets = new string[] {
"netcoreapp1.0",
"netcoreapp1.0/osx.10.11-x64"
};
foreach (var analyzer in analyzers)
{
var fileKey = $"LibC/1.2.3/{analyzer}";
var item = task.FileDefinitions.Where(t => t.ItemSpec == fileKey).First();
item.GetMetadata(MetadataKeys.Type).Should().Be("AnalyzerAssembly");
item.GetMetadata(MetadataKeys.Path).Should().Be(analyzer);
// expect two file dependencies for each, one per target
var fileDeps = task.FileDependencies.Where(t => t.ItemSpec == fileKey);
fileDeps.Count().Should().Be(2);
fileDeps.Select(f => f.GetMetadata(MetadataKeys.ParentTarget))
.Should().Contain(expectedTargets);
fileDeps.All(f => f.GetMetadata(MetadataKeys.ParentPackage) == "LibC/1.2.3");
}
}
private ResolvePackageDependencies GetExecutedTaskFromContents(string lockFileContents, out LockFile lockFile)
{
lockFile = TestLockFiles.CreateLockFile(lockFileContents);
return(GetExecutedTask(lockFile));
}
private ResolvePackageDependencies GetExecutedTaskFromPrefix(string lockFilePrefix, out LockFile lockFile)
{
lockFile = TestLockFiles.GetLockFile(lockFilePrefix);
return(GetExecutedTask(lockFile));
}
private ReportAssetsLogMessages GetExecutedTaskFromContents(string lockFileContents, MockLog logger)
{
var lockFile = TestLockFiles.CreateLockFile(lockFileContents);
return(GetExecutedTask(lockFile, logger));
}
