public async Task ThrowsOnNullPackage()
{
PackageDependencyInfo package = null;
var repository = StubSourceRepositoryFactory.Create();
await Assert.ThrowsAsync <ArgumentNullException>(
"package",
() => package.VisualizeUpgradeableDependenciesAsync(repository, _targetFramework));
}
public override void ReadManifest(XPathNavigator dependencyNav)
{
PackageDependency = new PackageDependencyInfo
{
PackageName = dependencyNav.Value,
Version = new Version(Util.ReadAttribute(dependencyNav, "version"))
};
}
internal IEnumerable<INodeLibraryDependencyInfo> AddPythonPackageDependency()
{
if (!CurrentWorkspaceHasIronPythonDependency())
return null;
var packageInfo = new PackageInfo(PythonPackage, PythonPackageVersion);
var packageDependencyInfo = new PackageDependencyInfo(packageInfo);
packageDependencyInfo.State = IsIronPythonPackageLoaded()
? PackageDependencyState.Loaded
: PackageDependencyState.Missing;
return new[] { packageDependencyInfo };
}
/// <summary>
/// Return the packages from a list that have a dependency on a specific package (id and version).
/// </summary>
/// <param name="package"></param>
/// <param name="packageDependencyInfos"></param>
/// <returns></returns>
public static IList <PackageDependencyInfo> GetDependantPackages(PackageDependencyInfo package, IList <PackageDependencyInfo> packageDependencyInfos)
{
var dependantPackages = new List <PackageDependencyInfo>();
foreach (var packageDependencyInfo in packageDependencyInfos)
{
if (packageDependencyInfo.Dependencies.Any(d => package.Id == d.Id && package.Version == d.VersionRange.MinVersion))
{
dependantPackages.Add(packageDependencyInfo);
}
}
return(dependantPackages);
}
internal IEnumerable <INodeLibraryDependencyInfo> AddPythonPackageDependency()
{
if (!ContainsIronPythonDependencyInCurrentWS())
{
return(null);
}
var packageInfo = new PackageInfo(PythonPackage, PythonPackageVersion);
var packageDependencyInfo = new PackageDependencyInfo(packageInfo);
packageDependencyInfo.State = IsIronPythonPackageLoaded()
? PackageDependencyState.Loaded
: PackageDependencyState.Missing;
return(new[] { packageDependencyInfo });
}
/// <summary>
/// Get ordered dependencies from the lock file
/// </summary>
/// <param name="lockFile"></param>
/// <returns></returns>
public static IReadOnlyList <LibraryIdentity> GetOrderedLockFileDependencies(LockFile lockFile)
{
var results = new List <LibraryIdentity>();
var dependencies = new HashSet <PackageDependencyInfo>(PackageIdentity.Comparer);
var typeMappings = new Dictionary <PackageDependencyInfo, LibraryIdentity>(PackageIdentity.Comparer);
foreach (var target in lockFile.Targets)
{
foreach (var targetLibrary in target.Libraries)
{
var identity = new PackageIdentity(targetLibrary.Name, targetLibrary.Version);
var dependency = new PackageDependencyInfo(identity, targetLibrary.Dependencies);
dependencies.Add(dependency);
if (!typeMappings.ContainsKey(dependency))
{
var libraryIdentity = new LibraryIdentity(
targetLibrary.Name,
targetLibrary.Version,
LibraryType.Parse(targetLibrary.Type));
typeMappings.Add(dependency, libraryIdentity);
}
}
}
// Sort dependencies
var sortedDependencies = TopologicalSortUtility.SortPackagesByDependencyOrder(dependencies);
foreach (var dependency in sortedDependencies)
{
// Convert back
// PackageDependencyInfo -> LibraryIdentity
results.Add(typeMappings[dependency]);
}
return(results);
}
public void PackageDependenciesUpdatedWhenCustomNodeResolvedByNewPackage()
{
// Load JSON file graph
string path = Path.Combine(TestDirectory, @"core\packageDependencyTests\CustomNodeContainedInMultiplePackages.dyn");
// Assert serialized package dependency is Clockwork
var clockworkInfo = new PackageDependencyInfo("Clockwork for Dynamo 2.x", new Version("2.1.2"));
using (StreamReader file = new StreamReader(path))
{
var data = file.ReadToEnd();
var json = (JObject)JsonConvert.DeserializeObject(data);
var pd = json[WorkspaceReadConverter.NodeLibraryDependenciesPropString];
var deserializedPDs = JsonConvert.DeserializeObject <List <INodeLibraryDependencyInfo> >(pd.ToString(),
new NodeLibraryDependencyConverter(CurrentDynamoModel.Logger));
Assert.AreEqual(1, deserializedPDs.Count);
var package = deserializedPDs.First();
Assert.AreEqual(clockworkInfo, package);
}
OpenModel(path);
// Assert clockwork is still the only dependency returned
var packageDependencies = CurrentDynamoModel.CurrentWorkspace.NodeLibraryDependencies;
Assert.AreEqual(1, packageDependencies.Count);
Assert.AreEqual(clockworkInfo, packageDependencies.First());
// Void package dependency for node
CurrentDynamoModel.CurrentWorkspace.VoidNodeDependency(Guid.Parse("d87512f7f69e433d86c729bac18bcfef"));
// Assert local package dependency overrides deserialized package dependency
var pi = GetPackageInfo("Custom Rounding");
packageDependencies = CurrentDynamoModel.CurrentWorkspace.NodeLibraryDependencies;
Assert.AreEqual(1, packageDependencies.Count);
Assert.AreEqual(pi, packageDependencies.First());
}
public void PackageDependencyStateTest()
{
// Load JSON file graph
string path = Path.Combine(TestDirectory, @"core\packageDependencyTests\PackageDependencyStates.dyn");
OpenModel(path);
// Assert the total number of package dependencies.
var packageDependenciesList = CurrentDynamoModel.CurrentWorkspace.NodeLibraryDependencies;
Assert.AreEqual(4, packageDependenciesList.Count);
// Check for Incorrect package state
PackageDependencyInfo firstPackage = (PackageDependencyInfo)packageDependenciesList[0];
Assert.AreEqual(new PackageDependencyInfo("MeshToolkit", new Version("2.0.1")), firstPackage);
Assert.AreEqual(PackageDependencyState.Missing, firstPackage.State);
// Check for Warning package state, where the actually package is missing
// but the nodes are resolved by a different package.
PackageDependencyInfo secondPackage = (PackageDependencyInfo)packageDependenciesList[1];
Assert.AreEqual(new PackageDependencyInfo("Clockwork for Dynamo 2.x", new Version("2.1.2")), secondPackage);
Assert.AreEqual(PackageDependencyState.Warning, secondPackage.State);
// Check for Missing package state
PackageDependencyInfo thirdPackage = (PackageDependencyInfo)packageDependenciesList[2];
Assert.AreEqual(new PackageDependencyInfo("Clockwork for Dynamo 1.x", new Version("1.33.0")), thirdPackage);
Assert.AreEqual(PackageDependencyState.IncorrectVersion, thirdPackage.State);
// Check for Loaded package state
PackageDependencyInfo lastPackage = (PackageDependencyInfo)packageDependenciesList.Last();
Assert.AreEqual(new PackageDependencyInfo("Dynamo Samples", new Version("2.0.0")), lastPackage);
Assert.AreEqual(PackageDependencyState.Loaded, lastPackage.State);
}
/// <summary>
/// Helper that combines the results into the hashsets, which are passed by reference.
/// ***NOTE: Parameters combinedResults and foundIds may get updated before the return of this call
/// </summary>
private static void ProcessResults(HashSet<SourceDependencyInfo> combinedResults, SourceRepository source, HashSet<string> foundIds,
IEnumerable<PackageDependencyInfo> packages, bool includePrerelease)
{
if (packages != null)
{
foreach (var package in packages)
{
// Set the includePrerelease on the version range on every single package dependency to context.IncludePreerelease
var packageDependencies = package.Dependencies;
var modifiedPackageDependencies = new List<PackageDependency>();
foreach (var packageDependency in packageDependencies)
{
var versionRange = packageDependency.VersionRange;
var modifiedVersionRange = new Versioning.VersionRange(versionRange.MinVersion, versionRange.IsMinInclusive, versionRange.MaxVersion,
versionRange.IsMaxInclusive, includePrerelease, versionRange.Float);
var modifiedPackageDependency = new PackageDependency(packageDependency.Id, modifiedVersionRange);
modifiedPackageDependencies.Add(modifiedPackageDependency);
}
var modifiedPackageDependencyInfo = new PackageDependencyInfo(new PackageIdentity(package.Id, package.Version), modifiedPackageDependencies);
SourceDependencyInfo depInfo = new SourceDependencyInfo(modifiedPackageDependencyInfo, source);
// add this to the final results
combinedResults.Add(depInfo);
// mark that we found this id
foundIds.Add(depInfo.Id);
// mark that all dependant ids were also checked by the metadata client
foundIds.UnionWith(depInfo.Dependencies.Select(p => p.Id));
}
}
}
private static string GetPackageDependencyInfoId(PackageDependencyInfo info)
{
return(info.Id);
}
public ResolverPackage(PackageDependencyInfo info, bool absent)
: this(info.Id, info.Version, info.Dependencies, absent)
{
}
public void SerializeThenDeserialize_WithValidArguments_RoundTrips(PackageDependencyInfo expectedResult)
{
PackageDependencyInfo actualResult = SerializeThenDeserialize(PackageDependencyInfoFormatter.Instance, expectedResult);
Assert.Equal(expectedResult, actualResult);
}
/// <summary>
/// Regenerate dependency table
/// </summary>
/// <param name="ws">workspace model</param>
internal void DependencyRegen(WorkspaceModel ws)
{
// Clear the dependency table.
table.Columns.Clear();
foreach (var package in ws.NodeLibraryDependencies)
{
if (package is PackageDependencyInfo)
{
PackageDependencyInfo packageDependency = (PackageDependencyInfo)package;
// Different states for dependency packages.
switch (packageDependency.State)
{
case PackageDependencyState.Loaded:
table.Columns.Add(new Column()
{
ColumnsData = new ObservableCollection <ColumnData>()
{
new ColumnData(packageDependency.Name),
new ColumnData(packageDependency.Version.ToString(), 100)
}
});
break;
case PackageDependencyState.IncorrectVersion:
HasMissingPackage = true;
table.Columns.Add(new Column()
{
ColumnsData = new ObservableCollection <ColumnData>()
{
new ColumnData(packageDependency.Name),
new ColumnData(packageDependency.Version.ToString(), 100, ColumnData.WarningColor)
}
});
break;
case PackageDependencyState.Missing:
HasMissingPackage = true;
table.Columns.Add(new Column()
{
ColumnsData = new ObservableCollection <ColumnData>()
{
new ColumnData(packageDependency.Name, ColumnData.MissingColor),
new ColumnData(packageDependency.Version.ToString(), 100, ColumnData.MissingColor)
}
});
break;
case PackageDependencyState.Warning:
HasMissingPackage = true;
table.Columns.Add(new Column()
{
ColumnsData = new ObservableCollection <ColumnData>()
{
new ColumnData(packageDependency.Name, ColumnData.WarningColor),
new ColumnData(packageDependency.Version.ToString(), 100, ColumnData.WarningColor)
}
});
break;
}
}
}
}
public SourceDependencyInfo(PackageDependencyInfo info, SourceRepository source)
: base(info, info.Dependencies)
{
Source = source;
}
public void PackageGraphAnalysisUtilities_GetPackagesWithDependants_Succeeds()
{
// Set up
var packageIdentityA100 = new PackageIdentity("a", NuGetVersion.Parse("1.0.0"));
var packageIdentityB100 = new PackageIdentity("b", NuGetVersion.Parse("1.0.0"));
var packageIdentityC100 = new PackageIdentity("c", NuGetVersion.Parse("1.0.0"));
var packageIdentityC110 = new PackageIdentity("c", NuGetVersion.Parse("1.1.0"));
var packageIdentityD100 = new PackageIdentity("d", NuGetVersion.Parse("1.0.0"));
var packageDependencyInfos = new List <PackageDependencyInfo>();
var packageDependencyInfoA = new PackageDependencyInfo(packageIdentityA100,
new PackageDependency[] {
new PackageDependency(packageIdentityB100.Id, VersionRange.Parse(packageIdentityB100.Version.OriginalVersion)),
new PackageDependency(packageIdentityC100.Id, VersionRange.Parse(packageIdentityC100.Version.OriginalVersion)),
});
var packageDependencyInfoB = new PackageDependencyInfo(packageIdentityB100,
new PackageDependency[] {
new PackageDependency(packageIdentityD100.Id, VersionRange.Parse(packageIdentityD100.Version.OriginalVersion)),
});
var packageDependencyInfoC = new PackageDependencyInfo(packageIdentityC110, Enumerable.Empty <PackageDependency>());
var packageDependencyInfoD = new PackageDependencyInfo(packageIdentityD100, Enumerable.Empty <PackageDependency>());
packageDependencyInfos.Add(packageDependencyInfoA);
packageDependencyInfos.Add(packageDependencyInfoB);
packageDependencyInfos.Add(packageDependencyInfoC);
packageDependencyInfos.Add(packageDependencyInfoD);
// Act
var packageWithDependants = PackageGraphAnalysisUtilities.GetPackagesWithDependants(packageDependencyInfos);
// Assert
foreach (var package in packageWithDependants)
{
switch (package.Identity.Id)
{
case "a":
{
Assert.Equal(0, package.DependantPackages.Count);
Assert.True(package.IsTopLevelPackage);
break;
}
case "b":
{
Assert.Equal(1, package.DependantPackages.Count);
Assert.Equal(packageIdentityA100.Id, package.DependantPackages.Single().Id);
Assert.False(package.IsTopLevelPackage);
break;
}
case "c":
{
Assert.Equal(0, package.DependantPackages.Count);
Assert.True(package.IsTopLevelPackage);
break;
}
case "d":
{
Assert.Equal(1, package.DependantPackages.Count);
Assert.Equal(packageIdentityB100.Id, package.DependantPackages.Single().Id);
Assert.False(package.IsTopLevelPackage);
break;
}
default:
{
Assert.True(false, $"Unexpected package {package.Identity}");
break;
}
}
}
}
