/// <summary>
/// Validates that the compatible frameworks have compatible surface area.
/// </summary>
/// <param name="package">Nuget Package that needs to be validated.</param>
public void Validate(Package package)
{
_apiCompatRunner.InitializePaths(package.PackagePath, package.PackagePath);
IEnumerable <ContentItem> compileAssets = package.CompileAssets.OrderByDescending(t => ((NuGetFramework)t.Properties["tfm"]).Version);
ManagedCodeConventions conventions = new ManagedCodeConventions(null);
Queue <ContentItem> compileAssetsQueue = new Queue <ContentItem>(compileAssets);
while (compileAssetsQueue.Count > 0)
{
ContentItem compileTimeAsset = compileAssetsQueue.Dequeue();
ContentItemCollection contentItemCollection = new();
contentItemCollection.Load(compileAssetsQueue.Select(t => t.Path));
NuGetFramework framework = (NuGetFramework)compileTimeAsset.Properties["tfm"];
SelectionCriteria managedCriteria = conventions.Criteria.ForFramework(framework);
ContentItem compatibleFrameworkAsset = null;
if (package.HasRefAssemblies)
{
compatibleFrameworkAsset = contentItemCollection.FindBestItemGroup(managedCriteria, conventions.Patterns.CompileRefAssemblies)?.Items.FirstOrDefault();
}
else
{
compatibleFrameworkAsset = contentItemCollection.FindBestItemGroup(managedCriteria, conventions.Patterns.CompileLibAssemblies)?.Items.FirstOrDefault();
}
if (compatibleFrameworkAsset != null && compatibleFrameworkAsset.Path != compileTimeAsset.Path)
{
string header = string.Format(Resources.ApiCompatibilityHeader, compatibleFrameworkAsset.Path, compileTimeAsset.Path);
_apiCompatRunner.QueueApiCompatFromContentItem(package.PackageId, compatibleFrameworkAsset, compileTimeAsset, header);
}
}
_apiCompatRunner.RunApiCompat();
}
/// <summary>
/// Validates the latest nuget package doesnot drop any target framework/rid and does not introduce any breaking changes.
/// </summary>
/// <param name="package">Nuget Package that needs to be validated.</param>
public void Validate(Package package)
{
if (_runApiCompat)
{
_apiCompatRunner.InitializePaths(_baselinePackage.PackagePath, package.PackagePath);
}
foreach (ContentItem baselineCompileTimeAsset in _baselinePackage.RefAssets)
{
NuGetFramework baselineTargetFramework = (NuGetFramework)baselineCompileTimeAsset.Properties["tfm"];
ContentItem latestCompileTimeAsset = package.FindBestCompileAssetForFramework(baselineTargetFramework);
if (latestCompileTimeAsset == null)
{
_log.LogError(
new Suppression {
DiagnosticId = DiagnosticIds.TargetFrameworkDropped, Target = baselineTargetFramework.ToString()
},
DiagnosticIds.TargetFrameworkDropped,
Resources.MissingTargetFramework,
baselineTargetFramework.ToString());
}
else if (_runApiCompat)
{
string header = string.Format(Resources.ApiCompatibilityBaselineHeader, baselineCompileTimeAsset.Path, latestCompileTimeAsset.Path, _baselinePackage.Version, package.Version);
_apiCompatRunner.QueueApiCompatFromContentItem(package.PackageId, baselineCompileTimeAsset, latestCompileTimeAsset, header, isBaseline: true);
}
}
foreach (ContentItem baselineRuntimeAsset in _baselinePackage.RuntimeAssets)
{
NuGetFramework baselineTargetFramework = (NuGetFramework)baselineRuntimeAsset.Properties["tfm"];
ContentItem latestRuntimeAsset = package.FindBestRuntimeAssetForFramework(baselineTargetFramework);
if (latestRuntimeAsset == null)
{
_log.LogError(
new Suppression {
DiagnosticId = DiagnosticIds.TargetFrameworkDropped, Target = baselineTargetFramework.ToString()
},
DiagnosticIds.TargetFrameworkDropped,
Resources.MissingTargetFramework,
baselineTargetFramework.ToString());
}
else
{
if (_runApiCompat)
{
string header = string.Format(Resources.ApiCompatibilityBaselineHeader, baselineRuntimeAsset.Path, latestRuntimeAsset.Path, _baselinePackage.Version, package.Version);
_apiCompatRunner.QueueApiCompatFromContentItem(package.PackageId, baselineRuntimeAsset, latestRuntimeAsset, header, isBaseline: true);
}
}
}
foreach (ContentItem baselineRuntimeSpecificAsset in _baselinePackage.RuntimeSpecificAssets)
{
NuGetFramework baselineTargetFramework = (NuGetFramework)baselineRuntimeSpecificAsset.Properties["tfm"];
string baselineRid = (string)baselineRuntimeSpecificAsset.Properties["rid"];
ContentItem latestRuntimeSpecificAsset = package.FindBestRuntimeAssetForFrameworkAndRuntime(baselineTargetFramework, baselineRid);
if (latestRuntimeSpecificAsset == null)
{
_log.LogError(
new Suppression {
DiagnosticId = DiagnosticIds.TargetFrameworkAndRidPairDropped, Target = baselineTargetFramework.ToString() + "-" + baselineRid
},
DiagnosticIds.TargetFrameworkAndRidPairDropped,
Resources.MissingTargetFrameworkAndRid,
baselineTargetFramework.ToString(),
baselineRid);
}
else
{
if (_runApiCompat)
{
string header = string.Format(Resources.ApiCompatibilityBaselineHeader, baselineRuntimeSpecificAsset.Path, latestRuntimeSpecificAsset.Path, _baselinePackage.Version, package.Version);
_apiCompatRunner.QueueApiCompatFromContentItem(package.PackageId, baselineRuntimeSpecificAsset, latestRuntimeSpecificAsset, header, isBaseline: true);
}
}
}
_apiCompatRunner.RunApiCompat();
}
/// <summary>
/// Validates that there are compile time and runtime assets for all the compatible frameworks.
/// Validates that the surface between compile time and runtime assets is compatible.
/// </summary>
/// <param name="package">Nuget Package that needs to be validated.</param>
public void Validate(Package package)
{
if (_runApiCompat)
{
_apiCompatRunner.InitializePaths(package.PackagePath, package.PackagePath);
}
HashSet <NuGetFramework> compatibleTargetFrameworks = new();
foreach (NuGetFramework item in package.FrameworksInPackage)
{
compatibleTargetFrameworks.Add(item);
if (s_packageTfmMapping.ContainsKey(item))
{
compatibleTargetFrameworks.UnionWith(s_packageTfmMapping[item]);
}
}
foreach (NuGetFramework framework in compatibleTargetFrameworks)
{
ContentItem compileTimeAsset = package.FindBestCompileAssetForFramework(framework);
if (compileTimeAsset == null)
{
_log.LogError(
new Suppression {
DiagnosticId = DiagnosticIds.ApplicableCompileTimeAsset, Target = framework.ToString()
},
DiagnosticIds.ApplicableCompileTimeAsset,
Resources.NoCompatibleCompileTimeAsset,
framework.ToString());
break;
}
ContentItem runtimeAsset = package.FindBestRuntimeAssetForFramework(framework);
if (runtimeAsset == null)
{
_log.LogError(
new Suppression {
DiagnosticId = DiagnosticIds.CompatibleRuntimeRidLessAsset, Target = framework.ToString()
},
DiagnosticIds.CompatibleRuntimeRidLessAsset,
Resources.NoCompatibleRuntimeAsset,
framework.ToString());
}
else
{
if (_runApiCompat && compileTimeAsset.Path != runtimeAsset.Path)
{
string header = string.Format(Resources.ApiCompatibilityHeader, compileTimeAsset.Path, runtimeAsset.Path);
_apiCompatRunner.QueueApiCompatFromContentItem(package.PackageId, compileTimeAsset, runtimeAsset, header);
}
}
foreach (string rid in package.Rids.Where(t => IsSupportedRidTargetFrameworkPair(framework, t)))
{
runtimeAsset = package.FindBestRuntimeAssetForFrameworkAndRuntime(framework, rid);
if (runtimeAsset == null)
{
_log.LogError(
new Suppression {
DiagnosticId = DiagnosticIds.CompatibleRuntimeRidSpecificAsset, Target = framework.ToString() + "-" + rid
},
DiagnosticIds.CompatibleRuntimeRidSpecificAsset,
Resources.NoCompatibleRidSpecificRuntimeAsset,
framework.ToString(),
rid);
}
else
{
if (_runApiCompat && compileTimeAsset.Path != runtimeAsset.Path)
{
string header = string.Format(Resources.ApiCompatibilityHeader, compileTimeAsset.Path, runtimeAsset.Path);
_apiCompatRunner.QueueApiCompatFromContentItem(package.PackageId, compileTimeAsset, runtimeAsset, header);
}
}
}
}
_apiCompatRunner.RunApiCompat();
}