public void ParseLibraries_LockFileTargetLibrariesWithDifferentCase_Throws()
{
// Arrange
var lockFileTarget = new LockFileTarget();
lockFileTarget.Libraries = new List <LockFileTargetLibrary>
{
new LockFileTargetLibrary()
{
Name = "packageA",
Type = "package",
Version = NuGetVersion.Parse("1.0.0")
},
new LockFileTargetLibrary()
{
Name = "PackageA",
Type = "package",
Version = NuGetVersion.Parse("1.0.0")
}
};
var exception = Assert.Throws <ArgumentException>(() => AssetsFileDependenciesSnapshot.ParseLibraries(lockFileTarget));
Assert.Contains("PackageA", exception.Message);
}
public void ParseLibraries_LockFileTargetLibrariesMatchesDependencies_Succeeds()
{
// Arrange
var lockFileTarget = new LockFileTarget();
lockFileTarget.Libraries = new List <LockFileTargetLibrary>
{
new LockFileTargetLibrary()
{
Name = "packageA",
Type = "package",
Version = NuGetVersion.Parse("1.0.0")
},
new LockFileTargetLibrary()
{
Name = "packageB",
Type = "package",
Version = NuGetVersion.Parse("1.0.0")
},
new LockFileTargetLibrary()
{
Name = "projectA",
Type = "project",
Version = NuGetVersion.Parse("1.0.0")
},
new LockFileTargetLibrary()
{
Name = "projectB",
Type = "project",
Version = NuGetVersion.Parse("1.0.0")
}
};
ImmutableDictionary <string, AssetsFileTargetLibrary> dependencies = AssetsFileDependenciesSnapshot.ParseLibraries(lockFileTarget);
Assert.Equal(lockFileTarget.Libraries.Count, dependencies.Count);
Assert.All <LockFileTargetLibrary>(lockFileTarget.Libraries,
source =>
{
Assert.True(dependencies.ContainsKey(source.Name));
AssetsFileTargetLibrary target = dependencies[source.Name];
Assert.Equal(source.Name, target.Name);
Assert.Equal(source.Version.ToNormalizedString(), target.Version);
AssetsFileLibraryType sourceType;
Assert.True(Enum.TryParse <AssetsFileLibraryType>(source.Type, ignoreCase: true, out sourceType));
Assert.Equal(sourceType, target.Type);
});
}
public void ParseLibraries_IgnoreCaseInDependenciesTree_Succeeds()
{
// Arrange
var lockFileContent = @"{
""version"": 3,
""targets"": {
""net5.0"": {
""System.Runtime/4.0.20-beta-22927"": {
""type"": ""package"",
""dependencies"": {
""Frob"": ""4.0.20""
},
""compile"": {
""ref/dotnet/System.Runtime.dll"": {}
}
}
}
},
""libraries"": {
""System.Runtime/4.0.20-beta-22927"": {
""sha512"": ""sup3rs3cur3"",
""type"": ""package"",
""files"": [
""System.Runtime.nuspec""
]
}
},
""projectFileDependencyGroups"": {
"""": [
""System.Runtime [4.0.10-beta-*, )""
],
""net5.0"": []
},
""logs"": [
{
""code"": ""NU1000"",
""level"": ""Error"",
""message"": ""test log message""
}
]
}";
var lockFileFormat = new LockFileFormat();
var lockFile = lockFileFormat.Parse(lockFileContent, "In Memory");
var dependencies = AssetsFileDependenciesSnapshot.ParseLibraries(lockFile.Targets.First());
Assert.Equal(1, dependencies.Count);
Assert.True(dependencies.ContainsKey("system.runtime"));
}
public async Task SearchAsync(IDependenciesTreeProjectSearchContext context)
{
// get latest snapshot
ExportProvider exportProvider = context.UnconfiguredProject.Services.ExportProvider;
Lazy <IAssetsFileDependenciesDataSource, IAppliesToMetadataView> dataSource
= exportProvider
.GetExports <IAssetsFileDependenciesDataSource, IAppliesToMetadataView>()
.SingleOrDefault(export => export.Metadata.AppliesTo(context.UnconfiguredProject.Capabilities));
if (dataSource == null)
{
// dataSource will be null for shared projects, for example
return;
}
IProjectDataSourceRegistry?dataSourceRegistry = context.UnconfiguredProject.Services.DataSourceRegistry;
Assumes.Present(dataSourceRegistry);
AssetsFileDependenciesSnapshot snapshot = (await dataSource.Value.GetLatestVersionAsync <AssetsFileDependenciesSnapshot>(dataSourceRegistry, cancellationToken: context.CancellationToken)).Value;
if (!(context.UnconfiguredProject.Services.ExportProvider.GetExportedValue <IActiveConfigurationGroupService>() is IActiveConfigurationGroupService3 activeConfigurationGroupService))
{
return;
}
IConfigurationGroup <ConfiguredProject> configuredProjects = await activeConfigurationGroupService.GetActiveLoadedConfiguredProjectGroupAsync();
foreach ((_, AssetsFileTarget target) in snapshot.DataByTarget)
{
ConfiguredProject?configuredProject = await FindConfiguredProjectAsync(target.TargetFrameworkMoniker);
if (configuredProject == null)
{
continue;
}
IDependenciesTreeConfiguredProjectSearchContext?targetContext = await context.ForConfiguredProjectAsync(configuredProject);
if (targetContext == null)
{
continue;
}
foreach ((_, AssetsFileTargetLibrary library) in target.LibraryByName)
{
if (context.CancellationToken.IsCancellationRequested)
{
// Search was cancelled
return;
}
if (targetContext.IsMatch(library.Name))
{
targetContext.SubmitResult(CreateLibraryItem(library));
}
SearchAssemblies(library, library.CompileTimeAssemblies, PackageAssemblyGroupType.CompileTime);
SearchAssemblies(library, library.FrameworkAssemblies, PackageAssemblyGroupType.Framework);
SearchContentFiles(library);
}
SearchLogMessages();
continue;
async Task <ConfiguredProject?> FindConfiguredProjectAsync(string tfm)
{
foreach (ConfiguredProject configuredProject in configuredProjects)
{
if (configuredProject.Services.ProjectSubscription == null)
{
continue;
}
IProjectSubscriptionUpdate subscriptionUpdate = (await configuredProject.Services.ProjectSubscription.ProjectRuleSource.GetLatestVersionAsync(configuredProject, cancellationToken: context.CancellationToken)).Value;
if (subscriptionUpdate.CurrentState.TryGetValue(NuGetRestoreRule.SchemaName, out IProjectRuleSnapshot nuGetRestoreSnapshot) &&
nuGetRestoreSnapshot.Properties.TryGetValue(NuGetRestoreRule.NuGetTargetMonikerProperty, out string nuGetTargetMoniker) &&
StringComparer.OrdinalIgnoreCase.Equals(nuGetTargetMoniker, tfm))
{
// Assets file 'target' string matches the configure project's NuGetTargetMoniker property value
return(configuredProject);
}
if (subscriptionUpdate.CurrentState.TryGetValue(ConfigurationGeneralRule.SchemaName, out IProjectRuleSnapshot configurationGeneralSnapshot) &&
configurationGeneralSnapshot.Properties.TryGetValue(ConfigurationGeneralRule.TargetFrameworkMonikerProperty, out string targetFrameworkMoniker) &&
StringComparer.OrdinalIgnoreCase.Equals(targetFrameworkMoniker, tfm))
{
// Assets file 'target' string matches the configure project's TargetFrameworkMoniker property value
return(configuredProject);
}
}
// No project found
return(null);
}
void SearchAssemblies(AssetsFileTargetLibrary library, ImmutableArray <string> assemblies, PackageAssemblyGroupType groupType)
{
foreach (string assembly in assemblies)
{
if (targetContext.IsMatch(Path.GetFileName(assembly)))
{
targetContext.SubmitResult(new PackageAssemblyItem(target, library, assembly, groupType));
}
}
}
void SearchContentFiles(AssetsFileTargetLibrary library)
{
foreach (AssetsFileTargetLibraryContentFile contentFile in library.ContentFiles)
{
if (targetContext.IsMatch(contentFile.Path))
{
targetContext.SubmitResult(new PackageContentFileItem(target, library, contentFile, _fileIconProvider));
}
}
}
IRelatableItem CreateLibraryItem(AssetsFileTargetLibrary library)
{
return(library.Type switch
{
AssetsFileLibraryType.Package => new PackageReferenceItem(target, library),
AssetsFileLibraryType.Project => new ProjectReferenceItem(target, library),
_ => throw Assumes.NotReachable()
});
}
void SearchLogMessages()
{
foreach (AssetsFileLogMessage log in target.Logs)
{
if (targetContext.IsMatch(log.Message))
{
targetContext.SubmitResult(CreateLogItem(log));
}
}
DiagnosticItem?CreateLogItem(AssetsFileLogMessage log)
{
if (target.LibraryByName.TryGetValue(log.LibraryName, out AssetsFileTargetLibrary? library))
{
return(new DiagnosticItem(target, library, log));
}
return(null);
}
}
}
