public async Task GetByPackageDeserializationException()
{
// Arrange
var desiredPackageId = "brokenpackage";
var desiredPackageVersion = "99.9.99";
var storageFactory = new MemoryStorageFactory();
var storage = storageFactory.Create(PackageState.Valid.ToString().ToLowerInvariant());
await storage.SaveAsync(
storage.ResolveUri($"{desiredPackageId}/{desiredPackageId}.{desiredPackageVersion}.json"),
new StringStorageContent("this isn't json"),
CancellationToken.None);
var statusService = new PackageMonitoringStatusService(
storageFactory,
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
// Act
var status = await statusService.GetAsync(new FeedPackageIdentity(desiredPackageId, desiredPackageVersion), CancellationToken.None);
// Assert
Assert.Equal(desiredPackageId, status.Package.Id);
Assert.Equal(desiredPackageVersion, status.Package.Version);
Assert.IsType <StatusDeserializationException>(status.ValidationException);
}
public async Task UpdateSavesNewStatus()
{
// Arrange
var feedPackageIdentity = new FeedPackageIdentity("howdy", "3.4.6");
var packageValidationResult = new PackageValidationResult(
new PackageIdentity(feedPackageIdentity.Id, new NuGetVersion(feedPackageIdentity.Version)),
null,
null,
Enumerable.Empty <AggregateValidationResult>());
var status = new PackageMonitoringStatus(packageValidationResult);
var storageFactory = new MemoryStorageFactory();
var statusService = new PackageMonitoringStatusService(
storageFactory,
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
// Act
await statusService.UpdateAsync(status, CancellationToken.None);
// Assert
Assert.True(
storageFactory.Create(
PackageState.Valid.ToString().ToLowerInvariant())
.Exists(GetPackageFileName(feedPackageIdentity.Id, feedPackageIdentity.Version)));
}
public async Task GetByPackageDeletesOutdatedStatuses(PackageState latest, PackageState outdated)
{
// Arrange
var storageFactory = new MemoryStorageFactory();
var statusService = new PackageMonitoringStatusService(
storageFactory,
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
var id = "howdyFriend";
var version = "5.5.5";
var package = new FeedPackageIdentity(id, version);
var outdatedStatus = PackageMonitoringStatusTestUtility.CreateStatusWithPackageValidationResult(
id,
version,
PackageMonitoringStatusTestUtility.GetTestResultFromPackageState(latest),
new DateTime(2019, 6, 10));
var latestStatus = PackageMonitoringStatusTestUtility.CreateStatusWithPackageValidationResult(
id,
version,
PackageMonitoringStatusTestUtility.GetTestResultFromPackageState(outdated),
new DateTime(2019, 6, 11));
await SaveToStorage(storageFactory, outdatedStatus);
await SaveToStorage(storageFactory, latestStatus);
// Act
var status = await statusService.GetAsync(package, CancellationToken.None);
// Assert
PackageMonitoringStatusTestUtility.AssertStatus(latestStatus, status);
Assert.Equal(latest == outdated, DoesPackageExists(storageFactory, outdatedStatus.State, package));
Assert.True(DoesPackageExists(storageFactory, latestStatus.State, package));
}
private bool DoesPackageExists(MemoryStorageFactory storageFactory, PackageState state, FeedPackageIdentity package)
{
var stateName = Enum.GetName(typeof(PackageState), state);
var storage = storageFactory.Create(stateName.ToLowerInvariant());
var packageFileName = GetPackageFileName(package.Id, package.Version);
return(storage.Exists(packageFileName));
}
private Task SaveToStorage(MemoryStorageFactory storageFactory, PackageState state, FeedPackageIdentity package, StorageContent content)
{
var stateName = Enum.GetName(typeof(PackageState), state);
var storage = storageFactory.Create(stateName.ToLowerInvariant());
var packageFileName = GetPackageFileName(package.Id, package.Version);
return(storage.SaveAsync(storage.ResolveUri(packageFileName), content, CancellationToken.None));
}
private Task SaveToStorage(MemoryStorageFactory storageFactory, PackageMonitoringStatus status)
{
var json = JsonConvert.SerializeObject(status, JsonSerializerUtility.SerializerSettings);
var content = new StringStorageContentWithAccessCondition(
json,
AccessCondition.GenerateEmptyCondition(),
"application/json");
return(SaveToStorage(storageFactory, status.State, status.Package, content));
}
public async Task UpdateDeletesOldStatuses(PackageState?previousState)
{
// Arrange
var feedPackageIdentity = new FeedPackageIdentity("howdy", "3.4.6");
var packageValidationResult = new PackageValidationResult(
new PackageIdentity(feedPackageIdentity.Id, new NuGetVersion(feedPackageIdentity.Version)),
null,
null,
Enumerable.Empty <AggregateValidationResult>());
var status = new PackageMonitoringStatus(packageValidationResult);
var storageFactory = new MemoryStorageFactory();
var statusService = new PackageMonitoringStatusService(
storageFactory,
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
var etag = "theETag";
foreach (var state in Enum.GetValues(typeof(PackageState)).Cast <PackageState>())
{
if (previousState != state)
{
status.ExistingState[state] = AccessCondition.GenerateIfNotExistsCondition();
continue;
}
var content = new StringStorageContentWithETag("{}", etag);
await SaveToStorage(storageFactory, state, feedPackageIdentity, content);
status.ExistingState[state] = AccessCondition.GenerateIfMatchCondition(etag);
}
// Act
await statusService.UpdateAsync(status, CancellationToken.None);
// Assert
foreach (var state in Enum.GetValues(typeof(PackageState)).Cast <PackageState>())
{
Assert.Equal(
state == status.State,
DoesPackageExists(storageFactory, state, feedPackageIdentity));
}
PackageMonitoringStatusTestUtility.AssertStatus(
status,
await statusService.GetAsync(feedPackageIdentity, CancellationToken.None));
}
public async Task UpdateDeletesOldStatuses()
{
// Arrange
var feedPackageIdentity = new FeedPackageIdentity("howdy", "3.4.6");
var packageFileName = GetPackageFileName(feedPackageIdentity.Id, feedPackageIdentity.Version);
var packageValidationResult = new PackageValidationResult(
new PackageIdentity(feedPackageIdentity.Id, new NuGetVersion(feedPackageIdentity.Version)),
null,
null,
Enumerable.Empty <AggregateValidationResult>());
var status = new PackageMonitoringStatus(packageValidationResult);
var storageFactory = new MemoryStorageFactory();
var statusService = new PackageMonitoringStatusService(
storageFactory,
new Mock <ILogger <PackageMonitoringStatusService> >().Object);
foreach (var state in Enum.GetNames(typeof(PackageState)))
{
var storage = storageFactory.Create(state.ToLowerInvariant());
await storage.SaveAsync(storage.ResolveUri(packageFileName), new StringStorageContent("{}"), CancellationToken.None);
Assert.True(storage.Exists(packageFileName));
}
// Act
await statusService.UpdateAsync(status, CancellationToken.None);
// Assert
foreach (var state in Enum.GetNames(typeof(PackageState)))
{
var storage = storageFactory.Create(state.ToLowerInvariant());
if ((PackageState)Enum.Parse(typeof(PackageState), state) == status.State)
{
Assert.True(storage.Exists(packageFileName));
}
else
{
Assert.False(storage.Exists(packageFileName));
}
}
AssertStatus(status, await statusService.GetAsync(feedPackageIdentity, CancellationToken.None));
}
