public async Task DropsMessageOnDuplicateValidationRequest()
{
var messageData = new PackageValidationMessageData("packageId", "1.2.3", Guid.NewGuid(), ValidatingType.SymbolPackage);
var validationConfiguration = new ValidationConfiguration();
var symbolPackage = new SymbolPackage()
{
Package = new Package()
};
var symbolPackageValidatingEntity = new SymbolPackageValidatingEntity(symbolPackage);
CoreSymbolPackageServiceMock
.Setup(ps => ps.FindPackageByIdAndVersionStrict(messageData.PackageId, messageData.PackageVersion))
.Returns(symbolPackageValidatingEntity)
.Verifiable();
ValidationSetProviderMock
.Setup(vsp => vsp.TryGetOrCreateValidationSetAsync(messageData, symbolPackageValidatingEntity))
.ReturnsAsync((PackageValidationSet)null)
.Verifiable();
var handler = CreateHandler();
var result = await handler.HandleAsync(messageData);
Assert.True(result);
CoreSymbolPackageServiceMock
.Verify(ps => ps.FindPackageByIdAndVersionStrict(messageData.PackageId, messageData.PackageVersion), Times.Once());
ValidationSetProviderMock
.Verify(vsp => vsp.TryGetOrCreateValidationSetAsync(messageData, symbolPackageValidatingEntity), Times.Once());
}
public void RemovePackage(Guid systemid)
{
SymbolPackage symbolPackage = GetPackage(systemid);
_dbContext.SymbolPackages.Remove(symbolPackage);
_dbContext.SaveChanges();
}
public ActionResult Edit(Guid?systemid)
{
ViewBag.IsAdmin = false;
if (Request.IsAuthenticated)
{
ViewBag.IsAdmin = _authorizationService.IsAdmin();
}
if (systemid == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (!ViewBag.IsAdmin)
{
return(new HttpStatusCodeResult(HttpStatusCode.Unauthorized));
}
SymbolPackage symbolPackage = _symbolService.GetPackage(systemid.Value);
if (symbolPackage == null)
{
return(HttpNotFound());
}
ViewBag.Themes = new SelectList(CodeList.Themes(), "Key", "Value", symbolPackage.Theme);
return(View(symbolPackage));
}
public SymbolsMessageServiceFacts()
{
EmailConfiguration = new EmailConfiguration
{
PackageUrlTemplate = "https://example.com/package/{0}/{1}",
PackageSupportTemplate = "https://example.com/packageSupport/{0}/{1}",
EmailSettingsUrl = ValidSettingsUrl,
AnnouncementsUrl = "https://announcements.com",
TwitterUrl = "https://twitter.com/nuget",
GalleryNoReplyAddress = "NuGet Gallery <*****@*****.**>",
GalleryOwner = "NuGet Gallery <*****@*****.**>"
};
EmailConfigurationAccessorMock
.SetupGet(eca => eca.Value)
.Returns(EmailConfiguration);
var package = new Package
{
PackageRegistration = new PackageRegistration {
Id = "package"
},
Version = "1.2.3.4",
NormalizedVersion = "1.2.3"
};
SymbolPackage = new SymbolPackage()
{
Package = package
};
ValidationSet = new PackageValidationSet();
}
public ActionResult Edit(SymbolPackage symbolPackage)
{
ViewBag.IsAdmin = false;
if (Request.IsAuthenticated)
{
ViewBag.IsAdmin = _authorizationService.IsAdmin();
}
if (!ViewBag.IsAdmin)
{
return(new HttpStatusCodeResult(HttpStatusCode.Unauthorized));
}
SymbolPackage symbolPackageOriginal = _symbolService.GetPackage(symbolPackage.SystemId);
ViewBag.Themes = new SelectList(CodeList.Themes(), "Key", "Value", symbolPackage.Theme);
if (ModelState.IsValid)
{
try
{
_symbolService.UpdatePackage(symbolPackageOriginal, symbolPackage);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
Log.Error(ex);
ModelState.AddModelError("error", ex.Message);
}
}
return(View(symbolPackage));
}
public SymbolPackageValidationTakingTooLongMessage(
IMessageServiceConfiguration configuration,
SymbolPackage symbolPackage,
string packageUrl)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_symbolPackage = symbolPackage ?? throw new ArgumentNullException(nameof(symbolPackage));
_packageUrl = packageUrl ?? throw new ArgumentNullException(nameof(packageUrl));
}
public async Task UpdateStatusAsyncMethodDoesNotUpdatePreviosAvailableStatusOnFailedValidation()
{
// Arrange
string packageId = "Test";
string packageVersion = "1.1.0";
int packageKey = 1;
Package p = new Package()
{
NormalizedVersion = packageVersion,
PackageRegistration = new PackageRegistration()
{
Id = packageId
},
Key = packageKey
};
SymbolPackage s1 = new SymbolPackage()
{
Package = p,
PackageKey = p.Key,
Key = 1,
StatusKey = PackageStatus.Available
};
SymbolPackage s2 = new SymbolPackage()
{
Package = p,
PackageKey = p.Key,
Key = 2,
StatusKey = PackageStatus.Validating
};
List <SymbolPackage> testSymbols = new List <SymbolPackage>()
{
s1, s2
};
_coreSymbolPackageService.Setup(c => c.FindSymbolPackagesByIdAndVersion(It.IsAny <string>(), It.IsAny <string>())).
Returns(testSymbols);
_coreSymbolPackageService.Setup(c => c.UpdateStatusAsync(It.Is <SymbolPackage>(symbol => symbol.Key == 1), PackageStatus.Deleted, false)).
Callback(
() => s1.StatusKey = PackageStatus.Deleted
).
Returns(Task.FromResult(0));
_coreSymbolPackageService.Setup(c => c.UpdateStatusAsync(It.Is <SymbolPackage>(symbol => symbol.Key == 2), PackageStatus.FailedValidation, true)).
Callback(
() => s2.StatusKey = PackageStatus.FailedValidation
).
Returns(Task.FromResult(0));
// Act
await _target.UpdateStatusAsync(s2, PackageStatus.FailedValidation);
// Assert
Assert.Equal(PackageStatus.FailedValidation, s2.StatusKey);
Assert.Equal(PackageStatus.Available, s1.StatusKey);
}
public void GivenANullArgument_ItShouldThrow(
IMessageServiceConfiguration configuration,
SymbolPackage symbolPackage,
string packageUrl)
{
Assert.Throws <ArgumentNullException>(() => new SymbolPackageValidationTakingTooLongMessage(
configuration,
symbolPackage,
packageUrl));
}
// GET: SymbolPackages/Details/5
public ActionResult Details(Guid?systemid, string sortOrder)
{
if (systemid == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SymbolPackage symbolPackage = _symbolService.GetPackage(systemid.Value);
if (symbolPackage == null)
{
return(HttpNotFound());
}
switch (sortOrder)
{
case "symbolname_desc":
symbolPackage.Symbols = symbolPackage.Symbols.OrderByDescending(s => s.Name).ToList();
break;
case "owner":
symbolPackage.Symbols = symbolPackage.Symbols.OrderBy(s => s.Owner).ToList();
break;
case "owner_desc":
symbolPackage.Symbols = symbolPackage.Symbols.OrderByDescending(s => s.Owner).ToList();
break;
case "theme_desc":
symbolPackage.Symbols = symbolPackage.Symbols.OrderByDescending(s => s.Theme).ToList();
break;
case "theme":
symbolPackage.Symbols = symbolPackage.Symbols.OrderBy(s => s.Theme).ToList();
break;
default:
symbolPackage.Symbols = symbolPackage.Symbols.OrderBy(s => s.Name).ToList();
break;
}
if (string.IsNullOrEmpty(sortOrder))
{
sortOrder = "symbolname";
}
ViewBag.SymbolnameSortParm = sortOrder == "symbolname" ? "symbolname_desc" : "symbolname";
ViewBag.Owner = sortOrder == "owner" ? "owner_desc" : "owner";
ViewBag.Theme = sortOrder == "theme" ? "theme_desc" : "theme";
ViewBag.SortOrder = sortOrder;
return(View(symbolPackage));
}
// GET: SymbolPackages/Create
public ActionResult Create()
{
SymbolPackage symbolPackage = new SymbolPackage();
symbolPackage.Owner = ClaimsPrincipal.Current.GetOrganizationName();
ViewBag.IsAdmin = false;
if (Request.IsAuthenticated)
{
ViewBag.IsAdmin = _authorizationService.IsAdmin();
}
ViewBag.Themes = new SelectList(CodeList.Themes(), "Key", "Value", "Annen");
return(View(symbolPackage));
}
public FactsBase()
{
_packageKey = 42;
_symbolPackageKey = 420;
_package = new Package {
Key = _packageKey
};
_symbolPackage = new SymbolPackage()
{
Key = _symbolPackageKey
};
_validationKey = new Guid("ae05c5f9-eb2a-415b-ae42-92829bf201a7");
_validation = new PackageValidation
{
Key = _validationKey
};
_validationSetKey = 1001;
_validationSetTrackingId = new Guid("490e8d72-967a-485f-a035-67d5bba0af9f");
_validationSet = new PackageValidationSet
{
Key = _validationSetKey,
ValidationTrackingId = _validationSetTrackingId,
PackageValidations = new[] { _validation },
};
_validation.PackageValidationSet = _validationSet;
_validationSets = new Mock <IEntityRepository <PackageValidationSet> >();
_validations = new Mock <IEntityRepository <PackageValidation> >();
_packages = new Mock <IEntityRepository <Package> >();
_symbolPackages = new Mock <IEntityRepository <SymbolPackage> >();
_packages
.Setup(x => x.GetAll())
.Returns(() => new[] { _package }.AsQueryable());
_symbolPackages
.Setup(x => x.GetAll())
.Returns(() => new[] { _symbolPackage }.AsQueryable());
_validations
.Setup(x => x.GetAll())
.Returns(() => new[] { _validation }.AsQueryable());
_validationSets
.Setup(x => x.GetAll())
.Returns(() => new[] { _validationSet }.AsQueryable());
_target = new ValidationAdminService(
_validationSets.Object,
_validations.Object,
_packages.Object,
_symbolPackages.Object);
}
public ActionResult Delete(Guid?systemid)
{
if (systemid == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SymbolPackage symbolPackage = _symbolService.GetPackage(systemid.Value);
if (symbolPackage == null)
{
return(HttpNotFound());
}
return(View(symbolPackage));
}
public void GivenANullArgument_ItShouldThrow(
IMessageServiceConfiguration configuration,
SymbolPackage symbolPackage,
string packageUrl,
string packageSupportUrl,
string emailSettingsUrl,
IEnumerable <string> warningMessages)
{
Assert.Throws <ArgumentNullException>(() => new SymbolPackageAddedMessage(
configuration,
symbolPackage,
packageUrl,
packageSupportUrl,
emailSettingsUrl,
warningMessages));
}
public SymbolPackageAddedMessage(
IMessageServiceConfiguration configuration,
SymbolPackage package,
string packageUrl,
string packageSupportUrl,
string emailSettingsUrl,
IEnumerable <string> warningMessages)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_symbolPackage = package ?? throw new ArgumentNullException(nameof(package));
_packageUrl = packageUrl ?? throw new ArgumentNullException(nameof(packageUrl));
_packageSupportUrl = packageSupportUrl ?? throw new ArgumentNullException(nameof(packageSupportUrl));
_emailSettingsUrl = emailSettingsUrl ?? throw new ArgumentNullException(nameof(emailSettingsUrl));
_warningMessages = warningMessages;
_hasWarnings = warningMessages != null && warningMessages.Any();
}
public async Task SendSymbolPackageValidationFailedNoticeAsync(SymbolPackage symbolPackage, PackageValidationSet validationSet, string packageUrl, string packageSupportUrl, string announcementsUrl, string twitterUrl)
{
var validationIssues = validationSet.GetValidationIssues();
var subject = $"[{CoreConfiguration.GalleryOwner.DisplayName}] Symbol package validation failed - {symbolPackage.Id} {symbolPackage.Version}";
var bodyBuilder = new StringBuilder();
bodyBuilder.Append($@"The symbol package [{symbolPackage.Id} {symbolPackage.Version}]({packageUrl}) failed validation because of the following reason(s):
");
foreach (var validationIssue in validationIssues)
{
bodyBuilder.Append($@"
- {ParseValidationIssue(validationIssue, announcementsUrl, twitterUrl)}");
}
bodyBuilder.Append($@"
Your symbol package was not published on {CoreConfiguration.GalleryOwner.DisplayName} and is not available for consumption.
");
if (validationIssues.Any(i => i.IssueCode == ValidationIssueCode.Unknown))
{
bodyBuilder.Append($"Please [contact support]({packageSupportUrl}) to help.");
}
else
{
var issuePluralString = validationIssues.Count() > 1 ? "all the issues" : "the issue";
bodyBuilder.Append($"You can reupload your symbol package once you've fixed {issuePluralString} with it.");
}
using (var mailMessage = new MailMessage())
{
mailMessage.Subject = subject;
mailMessage.Body = bodyBuilder.ToString();
mailMessage.From = CoreConfiguration.GalleryNoReplyAddress;
AddAllOwnersToMailMessage(symbolPackage.Package.PackageRegistration, mailMessage);
if (mailMessage.To.Any())
{
await SendMessageAsync(mailMessage);
}
}
}
public SymbolPackageValidationFailedMessage(
IMessageServiceConfiguration configuration,
SymbolPackage symbolPackage,
PackageValidationSet validationSet,
string packageUrl,
string packageSupportUrl,
string announcementsUrl,
string twitterUrl)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_symbolPackage = symbolPackage ?? throw new ArgumentNullException(nameof(symbolPackage));
_validationSet = validationSet ?? throw new ArgumentNullException(nameof(validationSet));
_packageUrl = packageUrl ?? throw new ArgumentNullException(nameof(packageUrl));
_packageSupportUrl = packageSupportUrl ?? throw new ArgumentNullException(nameof(packageSupportUrl));
_announcementsUrl = announcementsUrl ?? throw new ArgumentNullException(nameof(announcementsUrl));
_twitterUrl = twitterUrl ?? throw new ArgumentNullException(nameof(twitterUrl));
}
public HttpResponseMessage PostPackage(SymbolPackage package)
{
try
{
return(Request.CreateResponse(HttpStatusCode.OK, _symbolService.AddPackage(package)));
}
catch (PackageException pex)
{
Log.Error("Error API", pex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, new HttpError(pex.Message)));
}
catch (Exception ex)
{
Log.Error("Error API", ex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, new HttpError("Kunne ikke legge til pakke")));
}
}
public void GivenANullArgument_ItShouldThrow(
IMessageServiceConfiguration configuration,
SymbolPackage symbolPackage,
PackageValidationSet packageValidationSet,
string packageUrl,
string packageSupportUrl,
string announcementsUrl,
string twitterUrl)
{
Assert.Throws <ArgumentNullException>(() => new SymbolPackageValidationFailedMessage(
configuration,
symbolPackage,
packageValidationSet,
packageUrl,
packageSupportUrl,
announcementsUrl,
twitterUrl));
}
public SymbolPackage AddPackage(SymbolPackage symbolPackage)
{
symbolPackage.SystemId = Guid.NewGuid();
string owner = ClaimsPrincipal.Current.GetOrganizationName();
if (_authorizationService.IsAdmin() && !string.IsNullOrEmpty(symbolPackage.Owner))
{
owner = symbolPackage.Owner;
}
symbolPackage.Owner = owner;
symbolPackage.Folder = CreatePackageFolder(symbolPackage.Name);
_dbContext.SymbolPackages.Add(symbolPackage);
_dbContext.SaveChanges();
return(symbolPackage);
}
public SymbolValidationMessageHandlerLooseFacts()
: base(MockBehavior.Loose)
{
SymbolPackage = new SymbolPackage()
{
Package = new Package()
};
MessageData = new PackageValidationMessageData("packageId", "1.2.3", Guid.NewGuid(), ValidatingType.SymbolPackage);
ValidationSet = new PackageValidationSet();
SymbolPackageValidatingEntity = new SymbolPackageValidatingEntity(SymbolPackage);
CoreSymbolPackageServiceMock
.Setup(ps => ps.FindPackageByIdAndVersionStrict(MessageData.PackageId, MessageData.PackageVersion))
.Returns(SymbolPackageValidatingEntity);
ValidationSetProviderMock
.Setup(vsp => vsp.TryGetOrCreateValidationSetAsync(MessageData, SymbolPackageValidatingEntity))
.ReturnsAsync(ValidationSet);
}
public async Task SendSymbolPackageAddedNoticeAsync(SymbolPackage symbolPackage, string packageUrl, string packageSupportUrl, string emailSettingsUrl, IEnumerable <string> warningMessages = null)
{
bool hasWarnings = warningMessages != null && warningMessages.Any();
string subject;
var warningMessagesPlaceholder = string.Empty;
if (hasWarnings)
{
subject = $"[{CoreConfiguration.GalleryOwner.DisplayName}] Symbol package published with warnings - {symbolPackage.Id} {symbolPackage.Version}";
warningMessagesPlaceholder = Environment.NewLine + string.Join(Environment.NewLine, warningMessages);
}
else
{
subject = $"[{CoreConfiguration.GalleryOwner.DisplayName}] Symbol package published - {symbolPackage.Id} {symbolPackage.Version}";
}
string body = $@"The symbol package [{symbolPackage.Id} {symbolPackage.Version}]({packageUrl}) was recently published on {CoreConfiguration.GalleryOwner.DisplayName} by {symbolPackage.Package.User.Username}. If this was not intended, please [contact support]({packageSupportUrl}).
{warningMessagesPlaceholder}
-----------------------------------------------
<em style=""font-size: 0.8em;"">
To stop receiving emails as an owner of this package, sign in to the {CoreConfiguration.GalleryOwner.DisplayName} and
[change your email notification settings]({emailSettingsUrl}).
</em>";
using (var mailMessage = new MailMessage())
{
mailMessage.Subject = subject;
mailMessage.Body = body;
mailMessage.From = CoreConfiguration.GalleryNoReplyAddress;
AddOwnersSubscribedToPackagePushedNotification(symbolPackage.Package.PackageRegistration, mailMessage);
if (mailMessage.To.Any())
{
await SendMessageAsync(mailMessage);
}
}
}
public void UpdateStatusAsyncMethodNoopWhenSameStatus()
{
// Arrange
string packageId = "Test";
string packageVersion = "1.1.0";
int packageKey = 1;
Package p = new Package()
{
NormalizedVersion = packageVersion,
PackageRegistration = new PackageRegistration()
{
Id = packageId
},
Key = packageKey
};
SymbolPackage s = new SymbolPackage()
{
Package = p,
PackageKey = p.Key,
Key = 1,
StatusKey = PackageStatus.Available
};
List <SymbolPackage> testSymbols = new List <SymbolPackage>()
{
s
};
_coreSymbolPackageService.Setup(c => c.FindSymbolPackagesByIdAndVersion(It.IsAny <string>(), It.IsAny <string>())).
Returns(testSymbols);
// Act
var symbol = _target.UpdateStatusAsync(s, PackageStatus.Available);
// Assert
_coreSymbolPackageService.Verify(c => c.UpdateStatusAsync(It.IsAny <SymbolPackage>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()), Times.Never);
}
public async Task SendValidationTakingTooLongNoticeAsync(SymbolPackage symbolPackage, string packageUrl)
{
string subject = "[{0}] Symbol package validation taking longer than expected - {1} {2}";
string body = "It is taking longer than expected for your symbol package [{1} {2}]({3}) to get published.\n\n" +
"We are looking into it and there is no action on you at this time. We’ll send you an email notification when your symbol package has been published.\n\n" +
"Thank you for your patience.";
body = string.Format(
CultureInfo.CurrentCulture,
body,
CoreConfiguration.GalleryOwner.DisplayName,
symbolPackage.Id,
symbolPackage.Version,
packageUrl);
subject = string.Format(
CultureInfo.CurrentCulture,
subject,
CoreConfiguration.GalleryOwner.DisplayName,
symbolPackage.Id,
symbolPackage.Version);
using (var mailMessage = new MailMessage())
{
mailMessage.Subject = subject;
mailMessage.Body = body;
mailMessage.From = CoreConfiguration.GalleryNoReplyAddress;
AddOwnersSubscribedToPackagePushedNotification(symbolPackage.Package.PackageRegistration, mailMessage);
if (mailMessage.To.Any())
{
await SendMessageAsync(mailMessage);
}
}
}
public void UpdatePackage(SymbolPackage originalSymbolPackage, SymbolPackage symbolPackage)
{
var sortOrderUsed = _dbContext.SymbolPackages.Where(p => p.SystemId != originalSymbolPackage.SystemId && p.SortOrder == symbolPackage.SortOrder).FirstOrDefault();
if (sortOrderUsed != null)
{
throw new Exception("SortOrder allerede i bruk " + sortOrderUsed.Name);
}
if (originalSymbolPackage.Name != symbolPackage.Name)
{
originalSymbolPackage.Folder = RenamePackageFolder(originalSymbolPackage.Name, symbolPackage.Name);
}
originalSymbolPackage.Name = symbolPackage.Name;
originalSymbolPackage.OfficialStatus = symbolPackage.OfficialStatus;
originalSymbolPackage.Owner = symbolPackage.Owner;
originalSymbolPackage.Theme = symbolPackage.Theme;
originalSymbolPackage.SortOrder = symbolPackage.SortOrder;
_dbContext.Entry(originalSymbolPackage).State = EntityState.Modified;
_dbContext.SaveChanges();
}
public BaseFacts()
{
Package = new Package
{
PackageRegistration = new PackageRegistration()
{
Id = PackageId
},
PackageStatusKey = PackageStatus.Available,
Version = PackageVersion,
NormalizedVersion = PackageVersion,
Key = PackageKey
};
AvailableSymbolPackage = new SymbolPackage
{
Key = 1,
Package = Package,
PackageKey = PackageKey,
StatusKey = PackageStatus.Available
};
FailedSymbolPackage = new SymbolPackage
{
Key = 2,
Package = Package,
PackageKey = PackageKey,
StatusKey = PackageStatus.FailedValidation
};
ValidatingSymbolPackage = new SymbolPackage
{
Key = 3,
Package = Package,
PackageKey = 100,
StatusKey = PackageStatus.Validating
};
SymbolsPackageServiceMock = new Mock <IEntityService <SymbolPackage> >();
SymbolPackageFileServiceMock = new Mock <IValidationFileService>();
ValidatorProviderMock = new Mock <IValidatorProvider>();
TelemetryServiceMock = new Mock <ITelemetryService>();
LoggerMock = new Mock <ILogger <EntityStatusProcessor <SymbolPackage> > >();
var streamMetadata = new PackageStreamMetadata()
{
Size = 1,
Hash = "hash",
HashAlgorithm = CoreConstants.Sha512HashAlgorithmId
};
Target = new SymbolsStatusProcessor(
SymbolsPackageServiceMock.Object,
SymbolPackageFileServiceMock.Object,
ValidatorProviderMock.Object,
TelemetryServiceMock.Object,
LoggerMock.Object);
AvailableSymbolPackageValidatingEntity = new SymbolPackageValidatingEntity(AvailableSymbolPackage);
FailedSymbolPackageValidatingEntity = new SymbolPackageValidatingEntity(FailedSymbolPackage);
ValidatingSymbolPackageValidatingEntity = new SymbolPackageValidatingEntity(ValidatingSymbolPackage);
}
