private static ManagePackageViewModel.VersionDeprecationState GetVersionDeprecationState(
PackageDeprecation deprecation,
string text)
{
var result = new ManagePackageViewModel.VersionDeprecationState();
result.Text = text;
if (deprecation != null)
{
result.IsLegacy = deprecation.Status.HasFlag(PackageDeprecationStatus.Legacy);
result.HasCriticalBugs = deprecation.Status.HasFlag(PackageDeprecationStatus.CriticalBugs);
result.IsOther = deprecation.Status.HasFlag(PackageDeprecationStatus.Other);
result.AlternatePackageId = deprecation.AlternatePackageRegistration?.Id;
var alternatePackage = deprecation.AlternatePackage;
if (alternatePackage != null)
{
// A deprecation should not have both an alternate package registration and an alternate package.
// In case a deprecation does have both, we will hide the alternate package registration's ID in this model.
result.AlternatePackageId = alternatePackage?.Id;
result.AlternatePackageVersion = alternatePackage?.Version;
}
result.CustomMessage = deprecation.CustomMessage;
}
return(result);
}
public void ThrowsIfMultipleDeprecationsOfPackage()
{
// Arrange
var key = 190304;
var package = new Package
{
Key = key
};
var matchingDeprecation1 = new PackageDeprecation
{
PackageKey = key
};
var matchingDeprecation2 = new PackageDeprecation
{
PackageKey = key
};
var context = GetFakeContext();
context.Deprecations.AddRange(
new[] { matchingDeprecation1, matchingDeprecation2 });
// Act / Assert
Assert.Throws <InvalidOperationException>(
() => Get <PackageDeprecationService>().GetDeprecationByPackage(package));
}
public void GetsDeprecationOfPackage()
{
// Arrange
var key = 190304;
var package = new Package
{
Key = key
};
var differentDeprecation = new PackageDeprecation
{
PackageKey = 9925
};
var matchingDeprecation = new PackageDeprecation
{
PackageKey = key
};
var context = GetFakeContext();
context.Deprecations.AddRange(
new[] { differentDeprecation, matchingDeprecation });
// Act
var deprecation = Get <PackageDeprecationService>()
.GetDeprecationByPackage(package);
// Assert
Assert.Equal(matchingDeprecation, deprecation);
}
public void ThrowsIfMultipleDeprecationsOfPackage()
{
// Arrange
var key = 190304;
var package = new Package
{
Key = key
};
var matchingDeprecation1 = new PackageDeprecation
{
PackageKey = key
};
var matchingDeprecation2 = new PackageDeprecation
{
PackageKey = key
};
var repository = GetMock <IEntityRepository <PackageDeprecation> >();
repository
.Setup(x => x.GetAll())
.Returns(new[]
{
matchingDeprecation1,
matchingDeprecation2
}.AsQueryable());
// Act / Assert
Assert.Throws <InvalidOperationException>(
() => Get <PackageDeprecationService>().GetDeprecationByPackage(package));
}
public DisplayPackageViewModel Setup(
DisplayPackageViewModel viewModel,
Package package,
User currentUser,
PackageDeprecation deprecation,
string readMeHtml)
{
_listPackageItemViewModelFactory.Setup(viewModel, package, currentUser);
SetupCommon(viewModel, package, pushedBy: null);
return(SetupInternal(viewModel, package, currentUser, deprecation, readMeHtml));
}
public DisplayPackageViewModel(Package package, User currentUser, PackageDeprecation deprecation)
: this(package, currentUser, (string)null)
{
HasSemVer2Version = NuGetVersion.IsSemVer2;
HasSemVer2Dependency = package.Dependencies.ToList()
.Where(pd => !string.IsNullOrEmpty(pd.VersionSpec))
.Select(pd => VersionRange.Parse(pd.VersionSpec))
.Any(p => (p.HasUpperBound && p.MaxVersion.IsSemVer2) || (p.HasLowerBound && p.MinVersion.IsSemVer2));
Dependencies = new DependencySetsViewModel(package.Dependencies);
var packageHistory = package
.PackageRegistration
.Packages
.OrderByDescending(p => new NuGetVersion(p.Version))
.ToList();
PackageVersions = packageHistory.Select(p => new DisplayPackageViewModel(p, currentUser, GetPushedBy(p, currentUser))).ToList();
PushedBy = GetPushedBy(package, currentUser);
PackageFileSize = package.PackageFileSize;
LatestSymbolsPackage = package.LatestSymbolPackage();
LatestAvailableSymbolsPackage = LatestSymbolsPackage != null && LatestSymbolsPackage.StatusKey == PackageStatus.Available
? LatestSymbolsPackage
: package.LatestAvailableSymbolPackage();
if (packageHistory.Any())
{
// calculate the number of days since the package registration was created
// round to the nearest integer, with a min value of 1
// divide the total download count by this number
TotalDaysSinceCreated = Convert.ToInt32(Math.Max(1, Math.Round((DateTime.UtcNow - packageHistory.Min(p => p.Created)).TotalDays)));
DownloadsPerDay = TotalDownloadCount / TotalDaysSinceCreated; // for the package
DownloadsPerDayLabel = DownloadsPerDay < 1 ? "<1" : DownloadsPerDay.ToNuGetNumberString();
IsDotnetToolPackageType = package.PackageTypes.Any(e => e.Name.Equals("DotnetTool", StringComparison.OrdinalIgnoreCase));
}
if (deprecation != null)
{
AlternatePackageId = deprecation.AlternatePackageRegistration?.Id;
var alternatePackage = deprecation.AlternatePackage;
if (alternatePackage != null)
{
// A deprecation should not have both an alternate package registration and an alternate package.
// In case a deprecation does have both, we will hide the alternate package registration's ID in this model.
AlternatePackageId = alternatePackage?.Id;
AlternatePackageVersion = alternatePackage?.Version;
}
CustomMessage = deprecation.CustomMessage;
}
}
public static AuditedPackageDeprecation CreateFrom(PackageDeprecation packageDeprecation)
{
return(new AuditedPackageDeprecation
{
Key = packageDeprecation.Key,
PackageKey = packageDeprecation.PackageKey,
Status = (int)packageDeprecation.Status,
AlternatePackageRegistrationKey = packageDeprecation.AlternatePackageRegistrationKey,
AlternatePackageKey = packageDeprecation.AlternatePackageKey,
DeprecatedByUserKey = packageDeprecation.DeprecatedByUserKey,
DeprecatedOn = packageDeprecation.DeprecatedOn,
CustomMessage = packageDeprecation.CustomMessage
});
}
public DisplayPackageViewModel Create(
Package package,
User currentUser,
PackageDeprecation deprecation,
string readmeHtml)
{
var viewModel = new DisplayPackageViewModel();
return(Setup(
viewModel,
package,
currentUser,
deprecation,
readmeHtml));
}
public DisplayPackageViewModel Create(
Package package,
User currentUser,
PackageDeprecation deprecation,
RenderedReadMeResult readmeResult)
{
var viewModel = new DisplayPackageViewModel();
return(Setup(
viewModel,
package,
currentUser,
deprecation,
readmeResult));
}
private static string GetWarningIconTitle(
string version,
PackageDeprecation deprecation,
PackageVulnerabilitySeverity?maxVulnerabilitySeverity)
{
// We want a tooltip title for the warning icon, which concatenates deprecation and vulnerability information cleanly
var deprecationTitle = "";
if (deprecation != null)
{
deprecationTitle = version;
var isLegacy = deprecation.Status.HasFlag(PackageDeprecationStatus.Legacy);
var hasCriticalBugs = deprecation.Status.HasFlag(PackageDeprecationStatus.CriticalBugs);
if (hasCriticalBugs)
{
if (isLegacy)
{
deprecationTitle += " is deprecated because it's legacy and has critical bugs";
}
else
{
deprecationTitle += " is deprecated because it has critical bugs";
}
}
else if (isLegacy)
{
deprecationTitle += " is deprecated because it's legacy and no longer maintained";
}
else
{
deprecationTitle += " is deprecated";
}
}
if (maxVulnerabilitySeverity.HasValue)
{
var severity = Enum.GetName(typeof(PackageVulnerabilitySeverity), maxVulnerabilitySeverity)?.ToLowerInvariant() ?? "unknown";
var vulnerabilitiesTitle = $"{version} has at least one vulnerability with {severity} severity.";
return(string.IsNullOrEmpty(deprecationTitle)
? vulnerabilitiesTitle
: $"{deprecationTitle}; {vulnerabilitiesTitle}");
}
return(string.IsNullOrEmpty(deprecationTitle)
? string.Empty
: $"{deprecationTitle}.");
}
public void GetsDeprecationOfPackage()
{
// Arrange
var differentDeprecation = new PackageDeprecation
{
Package = new Package
{
PackageRegistration = new PackageRegistration {
Id = "Bar"
}
}
};
var matchingDeprecation1 = new PackageDeprecation
{
Package = new Package
{
PackageRegistration = new PackageRegistration {
Id = "Foo"
}
}
};
var matchingDeprecation2 = new PackageDeprecation
{
Package = new Package
{
PackageRegistration = new PackageRegistration {
Id = "Foo"
}
}
};
var context = GetFakeContext();
context.Deprecations.AddRange(
new[] { differentDeprecation, matchingDeprecation1, matchingDeprecation2 });
var target = Get <PackageDeprecationService>();
// Act
var result = target.GetDeprecationsById("Foo");
// Assert
Assert.Equal(2, result.Count);
Assert.Equal(matchingDeprecation1, result[0]);
Assert.Equal(matchingDeprecation2, result[1]);
}
public void ReturnsCorrectSelectListText(bool latest, bool isLegacy, bool hasCriticalBugs, bool isOther, string expected)
{
var package = new Package
{
Version = Version,
IsLatestSemVer2 = latest
};
if (isLegacy || hasCriticalBugs || isOther)
{
var status = PackageDeprecationStatus.NotDeprecated;
if (isLegacy)
{
status |= PackageDeprecationStatus.Legacy;
}
if (hasCriticalBugs)
{
status |= PackageDeprecationStatus.CriticalBugs;
}
if (isOther)
{
status |= PackageDeprecationStatus.Other;
}
var deprecation = new PackageDeprecation
{
Status = status
};
package.Deprecations.Add(deprecation);
}
Assert.Equal(expected, PackageHelper.GetSelectListText(package));
}
public void GetsDeprecationOfPackage()
{
// Arrange
var key = 190304;
var package = new Package
{
Key = key
};
var differentDeprecation = new PackageDeprecation
{
PackageKey = 9925
};
var matchingDeprecation = new PackageDeprecation
{
PackageKey = key
};
var repository = GetMock <IEntityRepository <PackageDeprecation> >();
repository
.Setup(x => x.GetAll())
.Returns(new[]
{
differentDeprecation,
matchingDeprecation
}.AsQueryable());
// Act
var deprecation = Get <PackageDeprecationService>()
.GetDeprecationByPackage(package);
// Assert
Assert.Equal(matchingDeprecation, deprecation);
}
public async Task UpdateDeprecation(
IReadOnlyCollection <Package> packages,
PackageDeprecationStatus status,
PackageRegistration alternatePackageRegistration,
Package alternatePackage,
string customMessage,
User user)
{
if (packages == null || !packages.Any())
{
throw new ArgumentException(nameof(packages));
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var shouldDelete = status == PackageDeprecationStatus.NotDeprecated;
var deprecations = new List <PackageDeprecation>();
foreach (var package in packages)
{
var deprecation = package.Deprecations.SingleOrDefault();
if (shouldDelete)
{
if (deprecation != null)
{
package.Deprecations.Remove(deprecation);
deprecations.Add(deprecation);
}
}
else
{
if (deprecation == null)
{
deprecation = new PackageDeprecation
{
Package = package
};
package.Deprecations.Add(deprecation);
deprecations.Add(deprecation);
}
deprecation.Status = status;
deprecation.DeprecatedByUser = user;
deprecation.AlternatePackageRegistration = alternatePackageRegistration;
deprecation.AlternatePackage = alternatePackage;
deprecation.CustomMessage = customMessage;
}
}
if (shouldDelete)
{
_deprecationRepository.DeleteOnCommit(deprecations);
}
else
{
_deprecationRepository.InsertOnCommit(deprecations);
}
await _deprecationRepository.CommitChangesAsync();
}
private DisplayPackageViewModel SetupInternal(
DisplayPackageViewModel viewModel,
Package package,
User currentUser,
PackageDeprecation deprecation,
string readMeHtml)
{
viewModel.HasSemVer2Version = viewModel.NuGetVersion.IsSemVer2;
viewModel.HasSemVer2Dependency = package.Dependencies.ToList()
.Where(pd => !string.IsNullOrEmpty(pd.VersionSpec))
.Select(pd => VersionRange.Parse(pd.VersionSpec))
.Any(p => (p.HasUpperBound && p.MaxVersion.IsSemVer2) || (p.HasLowerBound && p.MinVersion.IsSemVer2));
viewModel.Dependencies = new DependencySetsViewModel(package.Dependencies);
var packageHistory = package
.PackageRegistration
.Packages
.OrderByDescending(p => new NuGetVersion(p.Version))
.ToList();
var pushedByCache = new Dictionary <User, string>();
viewModel.PackageVersions = packageHistory
.Select(
p =>
{
var vm = new DisplayPackageViewModel();
_listPackageItemViewModelFactory.Setup(vm, p, currentUser);
return(SetupCommon(vm, p, GetPushedBy(p, currentUser, pushedByCache)));
})
.ToList();
viewModel.PushedBy = GetPushedBy(package, currentUser, pushedByCache);
viewModel.PackageFileSize = package.PackageFileSize;
viewModel.LatestSymbolsPackage = package.LatestSymbolPackage();
viewModel.LatestAvailableSymbolsPackage = viewModel.LatestSymbolsPackage != null && viewModel.LatestSymbolsPackage.StatusKey == PackageStatus.Available
? viewModel.LatestSymbolsPackage
: package.LatestAvailableSymbolPackage();
if (packageHistory.Any())
{
// calculate the number of days since the package registration was created
// round to the nearest integer, with a min value of 1
// divide the total download count by this number
viewModel.TotalDaysSinceCreated = Convert.ToInt32(Math.Max(1, Math.Round((DateTime.UtcNow - packageHistory.Min(p => p.Created)).TotalDays)));
viewModel.DownloadsPerDay = viewModel.TotalDownloadCount / viewModel.TotalDaysSinceCreated; // for the package
viewModel.DownloadsPerDayLabel = viewModel.DownloadsPerDay < 1 ? "<1" : viewModel.DownloadsPerDay.ToNuGetNumberString();
viewModel.IsDotnetToolPackageType = package.PackageTypes.Any(e => e.Name.Equals("DotnetTool", StringComparison.OrdinalIgnoreCase));
}
if (deprecation != null)
{
viewModel.AlternatePackageId = deprecation.AlternatePackageRegistration?.Id;
var alternatePackage = deprecation.AlternatePackage;
if (alternatePackage != null)
{
// A deprecation should not have both an alternate package registration and an alternate package.
// In case a deprecation does have both, we will hide the alternate package registration's ID in this model.
viewModel.AlternatePackageId = alternatePackage?.Id;
viewModel.AlternatePackageVersion = alternatePackage?.Version;
}
viewModel.CustomMessage = deprecation.CustomMessage;
}
viewModel.ReadMeHtml = readMeHtml;
viewModel.HasEmbeddedIcon = package.HasEmbeddedIcon;
return(viewModel);
}
private DisplayPackageViewModel SetupCommon(
DisplayPackageViewModel viewModel,
Package package,
string pushedBy,
IReadOnlyDictionary <int, PackageDeprecation> packageKeyToDeprecation,
IReadOnlyDictionary <int, IReadOnlyList <PackageVulnerability> > packageKeyToVulnerabilities)
{
viewModel.NuGetVersion = NuGetVersion.Parse(NuGetVersionFormatter.ToFullString(package.Version));
viewModel.Copyright = package.Copyright;
viewModel.DownloadCount = package.DownloadCount;
viewModel.LastEdited = package.LastEdited;
viewModel.TotalDaysSinceCreated = 0;
viewModel.DownloadsPerDay = 0;
viewModel.PushedBy = pushedBy;
viewModel.InitializeRepositoryMetadata(package.RepositoryUrl, package.RepositoryType);
if (PackageHelper.TryPrepareUrlForRendering(package.ProjectUrl, out string projectUrl))
{
viewModel.ProjectUrl = projectUrl;
}
var fugetUrl = $"https://www.fuget.org/packages/{package.Id}/{package.NormalizedVersion}";
if (PackageHelper.TryPrepareUrlForRendering(fugetUrl, out string fugetReadyUrl))
{
viewModel.FuGetUrl = fugetReadyUrl;
}
viewModel.EmbeddedLicenseType = package.EmbeddedLicenseType;
viewModel.LicenseExpression = package.LicenseExpression;
if (PackageHelper.TryPrepareUrlForRendering(package.LicenseUrl, out string licenseUrl))
{
viewModel.LicenseUrl = licenseUrl;
var licenseNames = package.LicenseNames;
if (!string.IsNullOrEmpty(licenseNames))
{
viewModel.LicenseNames = licenseNames.Split(',').Select(l => l.Trim()).ToList();
}
}
PackageDeprecation deprecation = null;
if (packageKeyToDeprecation != null && packageKeyToDeprecation.TryGetValue(package.Key, out deprecation))
{
viewModel.DeprecationStatus = deprecation.Status;
}
else
{
viewModel.DeprecationStatus = PackageDeprecationStatus.NotDeprecated;
}
PackageVulnerabilitySeverity?maxVulnerabilitySeverity = null;
if (packageKeyToVulnerabilities != null &&
packageKeyToVulnerabilities.TryGetValue(package.Key, out var vulnerabilities) &&
vulnerabilities != null && vulnerabilities.Any())
{
viewModel.Vulnerabilities = vulnerabilities;
maxVulnerabilitySeverity = viewModel.Vulnerabilities.Max(v => v.Severity); // cache for messaging
viewModel.MaxVulnerabilitySeverity = maxVulnerabilitySeverity.Value;
}
else
{
viewModel.Vulnerabilities = null;
viewModel.MaxVulnerabilitySeverity = default;
}
viewModel.PackageWarningIconTitle =
GetWarningIconTitle(viewModel.Version, deprecation, maxVulnerabilitySeverity);
return(viewModel);
}
private static DisplayPackageViewModel CreateDisplayPackageViewModel(Package package, User currentUser = null, PackageDeprecation deprecation = null, string readmeHtml = null)
{
return(new DisplayPackageViewModelFactory(Mock.Of <IIconUrlProvider>()).Create(
package,
currentUser: currentUser,
deprecation: deprecation,
readmeHtml: readmeHtml));
}
public void DeprecationFieldsAreSetAsExpected(
PackageDeprecationStatus status,
bool hasAlternateRegistration,
bool hasAlternatePackage)
{
// Arrange
var deprecation = new PackageDeprecation
{
CustomMessage = "hello"
};
var alternateRegistrationId = "alternateRegistrationId";
if (hasAlternateRegistration)
{
var registration = new PackageRegistration
{
Id = alternateRegistrationId
};
deprecation.AlternatePackageRegistration = registration;
}
var alternatePackageRegistrationId = "alternatePackageRegistration";
var alternatePackageVersion = "1.0.0-alt";
if (hasAlternatePackage)
{
var alternatePackageRegistration = new PackageRegistration
{
Id = alternatePackageRegistrationId
};
var alternatePackage = new Package
{
Version = alternatePackageVersion,
PackageRegistration = alternatePackageRegistration
};
deprecation.AlternatePackage = alternatePackage;
}
var package = CreateTestPackage("1.0.0");
var linkedDeprecation = new PackageDeprecation
{
Status = status
};
package.Deprecations.Add(linkedDeprecation);
// Act
var model = new DisplayPackageViewModel(package, null, deprecation);
// Assert
Assert.Equal(status, model.DeprecationStatus);
Assert.Equal(deprecation.CustomMessage, model.CustomMessage);
if (hasAlternatePackage)
{
Assert.Equal(alternatePackageRegistrationId, model.AlternatePackageId);
Assert.Equal(alternatePackageVersion, model.AlternatePackageVersion);
}
else if (hasAlternateRegistration)
{
Assert.Equal(alternateRegistrationId, model.AlternatePackageId);
Assert.Null(model.AlternatePackageVersion);
}
else
{
Assert.Null(model.AlternatePackageId);
Assert.Null(model.AlternatePackageVersion);
}
var versionModel = model.PackageVersions.Single();
Assert.Equal(status, versionModel.DeprecationStatus);
Assert.Null(versionModel.AlternatePackageId);
Assert.Null(versionModel.AlternatePackageVersion);
Assert.Null(versionModel.CustomMessage);
}
public void DeprecationFieldsAreSetAsExpected(
PackageDeprecationStatus status,
SeverityString_State severity,
bool hasCves,
bool hasCwes,
bool hasAlternateRegistration,
bool hasAlternatePackage)
{
// Arrange
decimal?cvss;
switch (severity)
{
case SeverityString_State.Critical:
cvss = (decimal)9.5;
break;
case SeverityString_State.High:
cvss = (decimal)7.5;
break;
case SeverityString_State.Medium:
cvss = (decimal)5;
break;
case SeverityString_State.Low:
cvss = (decimal)2;
break;
case SeverityString_State.None:
cvss = null;
break;
default:
throw new ArgumentOutOfRangeException(nameof(severity));
}
var deprecation = new PackageDeprecation
{
CvssRating = cvss,
CustomMessage = "hello"
};
var cveIds = new[] { "CVE-2019-1111", "CVE-2019-2222" };
if (hasCves)
{
foreach (var cveId in cveIds)
{
var cve = new Cve
{
CveId = cveId
};
deprecation.Cves.Add(cve);
}
}
var cweIds = new[] { "CWE-1", "CWE-2" };
if (hasCwes)
{
foreach (var cweId in cweIds)
{
var cwe = new Cwe
{
CweId = cweId
};
deprecation.Cwes.Add(cwe);
}
}
var alternateRegistrationId = "alternateRegistrationId";
if (hasAlternateRegistration)
{
var registration = new PackageRegistration
{
Id = alternateRegistrationId
};
deprecation.AlternatePackageRegistration = registration;
}
var alternatePackageRegistrationId = "alternatePackageRegistration";
var alternatePackageVersion = "1.0.0-alt";
if (hasAlternatePackage)
{
var alternatePackageRegistration = new PackageRegistration
{
Id = alternatePackageRegistrationId
};
var alternatePackage = new Package
{
Version = alternatePackageVersion,
PackageRegistration = alternatePackageRegistration
};
deprecation.AlternatePackage = alternatePackage;
}
var package = CreateTestPackage("1.0.0");
var linkedDeprecation = new PackageDeprecation
{
Status = status
};
package.Deprecations.Add(linkedDeprecation);
// Act
var model = new DisplayPackageViewModel(package, null, deprecation);
// Assert
Assert.Equal(status, model.DeprecationStatus);
Assert.Equal(deprecation.CustomMessage, model.CustomMessage);
string expectedString;
switch (severity)
{
case SeverityString_State.Critical:
expectedString = "Critical";
break;
case SeverityString_State.High:
expectedString = "High";
break;
case SeverityString_State.Medium:
expectedString = "Medium";
break;
case SeverityString_State.Low:
expectedString = "Low";
break;
case SeverityString_State.None:
expectedString = null;
break;
default:
throw new ArgumentOutOfRangeException(nameof(severity));
}
Assert.Equal(expectedString, model.Severity);
if (hasCves)
{
Assert.Equal(cveIds, model.CveIds);
}
else
{
Assert.Empty(model.CveIds);
}
if (hasCwes)
{
Assert.Equal(cweIds, model.CweIds);
}
else
{
Assert.Empty(model.CweIds);
}
if (hasAlternatePackage)
{
Assert.Equal(alternatePackageRegistrationId, model.AlternatePackageId);
Assert.Equal(alternatePackageVersion, model.AlternatePackageVersion);
}
else if (hasAlternateRegistration)
{
Assert.Equal(alternateRegistrationId, model.AlternatePackageId);
Assert.Null(model.AlternatePackageVersion);
}
else
{
Assert.Null(model.AlternatePackageId);
Assert.Null(model.AlternatePackageVersion);
}
var versionModel = model.PackageVersions.Single();
Assert.Equal(status, versionModel.DeprecationStatus);
Assert.Null(versionModel.Severity);
Assert.Null(versionModel.CveIds);
Assert.Null(versionModel.CweIds);
Assert.Null(versionModel.AlternatePackageId);
Assert.Null(versionModel.AlternatePackageVersion);
Assert.Null(versionModel.CustomMessage);
}
public DeleteAccountTestService(User user, PackageRegistration userPackagesRegistration)
{
_user = user;
_user.ReservedNamespaces.Add(_reservedNamespace);
_user.Credentials.Add(_credential);
_credential.User = _user;
_user.SecurityPolicies.Add(_securityPolicy);
_userPackagesRegistration = userPackagesRegistration;
_userPackages = userPackagesRegistration.Packages;
SupportRequests.Add(new Issue()
{
CreatedBy = user.Username,
Key = 1,
IssueTitle = Strings.AccountDelete_SupportRequestTitle,
OwnerEmail = user.EmailAddress,
IssueStatusId = IssueStatusKeys.New,
HistoryEntries = new List <History>()
{
new History()
{
EditedBy = user.Username, IssueId = 1, Key = 1, IssueStatusId = IssueStatusKeys.New
}
}
});
SupportRequests.Add(new Issue()
{
CreatedBy = $"{user.Username}_second",
Key = 2,
IssueTitle = "Second",
OwnerEmail = "random",
IssueStatusId = IssueStatusKeys.New,
HistoryEntries = new List <History>()
{
new History()
{
EditedBy = $"{user.Username}_second", IssueId = 2, Key = 2, IssueStatusId = IssueStatusKeys.New
}
}
});
PackageOwnerRequests.Add(new PackageOwnerRequest()
{
PackageRegistration = new PackageRegistration()
{
Id = $"{user.Username}_first"
},
NewOwner = _user
});
PackageOwnerRequests.Add(new PackageOwnerRequest()
{
PackageRegistration = new PackageRegistration()
{
Id = $"{user.Username}_second"
},
NewOwner = _user
});
AccountDeletedByUser = new AccountDelete {
DeletedBy = _user, DeletedByKey = _user.Key
};
AccountDeletedByDifferentUser = new AccountDelete {
DeletedBy = new User {
Key = 1111
}, DeletedByKey = 1111
};
PackageDeletedByUser = new PackageDelete {
DeletedBy = _user, DeletedByKey = _user.Key
};
PackageDeletedByDifferentUser = new PackageDelete {
DeletedBy = new User {
Key = 1111
}, DeletedByKey = 1111
};
PackagePushedByUser = new Package
{
User = _user,
UserKey = _user.Key
};
DeprecationDeprecatedByUser = new PackageDeprecation
{
DeprecatedByUser = _user,
DeprecatedByUserKey = _user.Key
};
}
public void DeprecationFieldsAreSetAsExpected(
PackageDeprecationStatus status,
bool hasAlternateRegistration,
bool hasAlternatePackage)
{
// Arrange
var deprecation = new PackageDeprecation
{
Status = status,
CustomMessage = "hello",
};
var alternateRegistrationId = "alternateRegistrationId";
if (hasAlternateRegistration)
{
var registration = new PackageRegistration
{
Id = alternateRegistrationId
};
deprecation.AlternatePackageRegistration = registration;
}
var alternatePackageRegistrationId = "alternatePackageRegistration";
var alternatePackageVersion = "1.0.0-alt";
if (hasAlternatePackage)
{
var alternatePackageRegistration = new PackageRegistration
{
Id = alternatePackageRegistrationId
};
var alternatePackage = new Package
{
Version = alternatePackageVersion,
PackageRegistration = alternatePackageRegistration
};
deprecation.AlternatePackage = alternatePackage;
}
var package = CreateTestPackage("1.0.0");
var packageKeyToDeprecation = new Dictionary <int, PackageDeprecation>
{
{ 123, deprecation }
};
// Act
var model = CreateDisplayPackageViewModel(
package,
currentUser: null,
packageKeyToDeprecation: packageKeyToDeprecation,
readmeHtml: null);
// Assert
Assert.Equal(status, model.DeprecationStatus);
Assert.Equal(deprecation.CustomMessage, model.CustomMessage);
if (hasAlternatePackage)
{
Assert.Equal(alternatePackageRegistrationId, model.AlternatePackageId);
Assert.Equal(alternatePackageVersion, model.AlternatePackageVersion);
}
else if (hasAlternateRegistration)
{
Assert.Equal(alternateRegistrationId, model.AlternatePackageId);
Assert.Null(model.AlternatePackageVersion);
}
else
{
Assert.Null(model.AlternatePackageId);
Assert.Null(model.AlternatePackageVersion);
}
var versionModel = model.PackageVersions.Single();
Assert.Equal(status, versionModel.DeprecationStatus);
Assert.Null(versionModel.AlternatePackageId);
Assert.Null(versionModel.AlternatePackageVersion);
Assert.Null(versionModel.CustomMessage);
}
public async Task UpdateDeprecation(
IReadOnlyList <Package> packages,
PackageDeprecationStatus status,
PackageRegistration alternatePackageRegistration,
Package alternatePackage,
string customMessage,
User user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (packages == null || !packages.Any())
{
throw new ArgumentException(nameof(packages));
}
var registration = packages.First().PackageRegistration;
if (packages.Select(p => p.PackageRegistrationKey).Distinct().Count() > 1)
{
throw new ArgumentException("All packages to deprecate must have the same ID.", nameof(packages));
}
using (var strategy = new SuspendDbExecutionStrategy())
using (var transaction = _entitiesContext.GetDatabase().BeginTransaction())
{
var shouldDelete = status == PackageDeprecationStatus.NotDeprecated;
var deprecations = new List <PackageDeprecation>();
foreach (var package in packages)
{
var deprecation = package.Deprecations.SingleOrDefault();
if (shouldDelete)
{
if (deprecation != null)
{
package.Deprecations.Remove(deprecation);
deprecations.Add(deprecation);
}
}
else
{
if (deprecation == null)
{
deprecation = new PackageDeprecation
{
Package = package
};
package.Deprecations.Add(deprecation);
deprecations.Add(deprecation);
}
deprecation.Status = status;
deprecation.DeprecatedByUser = user;
deprecation.AlternatePackageRegistration = alternatePackageRegistration;
deprecation.AlternatePackage = alternatePackage;
deprecation.CustomMessage = customMessage;
}
}
if (shouldDelete)
{
_entitiesContext.Deprecations.RemoveRange(deprecations);
}
else
{
_entitiesContext.Deprecations.AddRange(deprecations);
}
await _entitiesContext.SaveChangesAsync();
await _packageUpdateService.UpdatePackagesAsync(packages);
transaction.Commit();
_telemetryService.TrackPackageDeprecate(
packages,
status,
alternatePackageRegistration,
alternatePackage,
!string.IsNullOrWhiteSpace(customMessage));
foreach (var package in packages)
{
await _auditingService.SaveAuditRecordAsync(
new PackageAuditRecord(
package,
status == PackageDeprecationStatus.NotDeprecated ? AuditedPackageAction.Undeprecate : AuditedPackageAction.Deprecate,
status == PackageDeprecationStatus.NotDeprecated ? PackageUndeprecatedVia.Web : PackageDeprecatedVia.Web));
}
}
}
