Change editor rule
This commit is contained in:
@@ -1,22 +1,23 @@
|
||||
using Musify.Infrastructure.Jobs;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Jobs;
|
||||
|
||||
public sealed class RecurringJobsRegistrarTests
|
||||
namespace Musify.Infrastructure.Tests.Jobs
|
||||
{
|
||||
[Theory]
|
||||
[InlineData(1, "*/1 * * * *")]
|
||||
[InlineData(59, "*/1 * * * *")]
|
||||
[InlineData(60, "*/1 * * * *")]
|
||||
[InlineData(61, "*/2 * * * *")]
|
||||
[InlineData(300, "*/5 * * * *")]
|
||||
[InlineData(3599, "0 */1 * * *")]
|
||||
[InlineData(3600, "0 */1 * * *")]
|
||||
[InlineData(7200, "0 */2 * * *")]
|
||||
[InlineData(0, "*/1 * * * *")]
|
||||
public void EveryCron_RoundsUpToWholeMinutes(int seconds, string expected)
|
||||
public sealed class RecurringJobsRegistrarTests
|
||||
{
|
||||
Assert.Equal(expected, RecurringJobsRegistrar.EveryCron(seconds));
|
||||
[Theory]
|
||||
[InlineData(1, "*/1 * * * *")]
|
||||
[InlineData(59, "*/1 * * * *")]
|
||||
[InlineData(60, "*/1 * * * *")]
|
||||
[InlineData(61, "*/2 * * * *")]
|
||||
[InlineData(300, "*/5 * * * *")]
|
||||
[InlineData(3599, "0 */1 * * *")]
|
||||
[InlineData(3600, "0 */1 * * *")]
|
||||
[InlineData(7200, "0 */2 * * *")]
|
||||
[InlineData(0, "*/1 * * * *")]
|
||||
public void EveryCron_RoundsUpToWholeMinutes(int seconds, string expected)
|
||||
{
|
||||
Assert.Equal(expected, RecurringJobsRegistrar.EveryCron(seconds));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+187
-186
@@ -6,200 +6,201 @@ using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
|
||||
using Musify.Infrastructure.Tests.TestSupport;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.MassTransit;
|
||||
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class DeleteRoutingSlipBuilderTests(InfrastructureTestFixture fixture)
|
||||
namespace Musify.Infrastructure.Tests.MassTransit
|
||||
{
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
[Fact]
|
||||
public async Task BuildAlbum_WithProcessedPictures_RemovesEveryPictureBeforeDeletingTheRow()
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class DeleteRoutingSlipBuilderTests(InfrastructureTestFixture fixture)
|
||||
{
|
||||
var album = await SeedAlbumAsync(new EntityPictures
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
[Fact]
|
||||
public async Task BuildAlbum_WithProcessedPictures_RemovesEveryPictureBeforeDeletingTheRow()
|
||||
{
|
||||
OriginalName = "original.webp",
|
||||
SmallName = "small.webp",
|
||||
MediumName = "medium.webp",
|
||||
LargeName = "large.webp"
|
||||
});
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildAlbumAsync(album.Id, album.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.MarkAlbumAsRemoving,
|
||||
ActivityNames.RemoveAlbumOriginalPicture,
|
||||
ActivityNames.RemoveAlbumSmallPicture,
|
||||
ActivityNames.RemoveAlbumMediumPicture,
|
||||
ActivityNames.RemoveAlbumLargePicture,
|
||||
ActivityNames.DeleteAlbumFromDb,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildAlbum_WithPendingPicture_OnlyRemovesTheOriginal()
|
||||
{
|
||||
var album = await SeedAlbumAsync(EntityPictures.Pending("original.webp"));
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildAlbumAsync(album.Id, album.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[ActivityNames.MarkAlbumAsRemoving, ActivityNames.RemoveAlbumOriginalPicture, ActivityNames.DeleteAlbumFromDb],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildAlbum_MissingAlbum_OnlyMarksAndDeletes()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildAlbumAsync(Guid.NewGuid(), 1, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[ActivityNames.MarkAlbumAsRemoving, ActivityNames.DeleteAlbumFromDb],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildPlayList_WithoutPictures_OnlyMarksAndDeletes()
|
||||
{
|
||||
var playList = await SeedPlayListAsync(pictures: null);
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildPlayListAsync(playList.Id, playList.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[ActivityNames.MarkPlayListAsRemoving, ActivityNames.DeletePlayListFromDb],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildPlayList_WithPictures_RemovesThemBetweenMarkAndDelete()
|
||||
{
|
||||
var playList = await SeedPlayListAsync(new EntityPictures { OriginalName = "original.webp", SmallName = "small.webp" });
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildPlayListAsync(playList.Id, playList.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.MarkPlayListAsRemoving,
|
||||
ActivityNames.RemovePlayListOriginalPicture,
|
||||
ActivityNames.RemovePlayListSmallPicture,
|
||||
ActivityNames.DeletePlayListFromDb,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildTrack_Unprocessed_NeverRemovesTheSharedPresetPictures()
|
||||
{
|
||||
var track = await SeedTrackAsync(new TrackPictures { OriginalName = "original.webp", SmallName = "preset.webp" }, new TrackAudio { OriginalName = "audio.mp3" });
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildTrackAsync(track.Id, track.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.MarkTrackAsRemoving,
|
||||
ActivityNames.RemoveTrackOriginalPicture,
|
||||
ActivityNames.RemoveTrackOriginalAudio,
|
||||
ActivityNames.DeleteTrackFromDb,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildTrack_Processed_RemovesResizedPicturesAndProcessedAudio()
|
||||
{
|
||||
var track = await SeedTrackAsync(
|
||||
new TrackPictures
|
||||
var album = await SeedAlbumAsync(new EntityPictures
|
||||
{
|
||||
OriginalName = "original.webp",
|
||||
SmallName = "s.webp",
|
||||
MediumName = "m.webp",
|
||||
LargeName = "l.webp",
|
||||
ProcessingStatus = ProcessingStatus.Completed
|
||||
},
|
||||
new TrackAudio { OriginalName = "audio.mp3", FolderName = "folder", TranscodeStatus = ProcessingStatus.Completed });
|
||||
await using var database = fixture.CreateDatabase();
|
||||
SmallName = "small.webp",
|
||||
MediumName = "medium.webp",
|
||||
LargeName = "large.webp"
|
||||
});
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildTrackAsync(track.Id, track.OwnerUserId, null, Ct)).Build();
|
||||
var slip = (await CreateBuilder(database).BuildAlbumAsync(album.Id, album.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.MarkTrackAsRemoving,
|
||||
ActivityNames.RemoveTrackOriginalPicture,
|
||||
ActivityNames.RemoveTrackSmallPicture,
|
||||
ActivityNames.RemoveTrackMediumPicture,
|
||||
ActivityNames.RemoveTrackLargePicture,
|
||||
ActivityNames.RemoveTrackOriginalAudio,
|
||||
ActivityNames.RemoveTrackProcessedAudio,
|
||||
ActivityNames.DeleteTrackFromDb,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.MarkAlbumAsRemoving,
|
||||
ActivityNames.RemoveAlbumOriginalPicture,
|
||||
ActivityNames.RemoveAlbumSmallPicture,
|
||||
ActivityNames.RemoveAlbumMediumPicture,
|
||||
ActivityNames.RemoveAlbumLargePicture,
|
||||
ActivityNames.DeleteAlbumFromDb,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
private static DeleteRoutingSlipBuilder CreateBuilder(Musify.Application.Contracts.IDatabase database) =>
|
||||
new(
|
||||
database,
|
||||
new TrackConfiguration(),
|
||||
new AlbumConfiguration(),
|
||||
new PlayListConfiguration(),
|
||||
new ApplicationStorageConfiguration { Bucket = "bucket" });
|
||||
|
||||
private async Task<User> SeedUserAsync()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"delete-{Guid.NewGuid():N}"[..30];
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return user;
|
||||
}
|
||||
|
||||
private async Task<Album> SeedAlbumAsync(EntityPictures? pictures)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"album-{Guid.NewGuid():N}";
|
||||
var album = new Album { Title = title, NormalizedTitle = title.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
|
||||
await database.Albums.AddAsync(album, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return album;
|
||||
}
|
||||
|
||||
private async Task<PlayList> SeedPlayListAsync(EntityPictures? pictures)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"pl-{Guid.NewGuid():N}"[..30];
|
||||
var playList = new PlayList { Name = name, NormalizedName = name.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
|
||||
await database.PlayLists.AddAsync(playList, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return playList;
|
||||
}
|
||||
|
||||
private async Task<Track> SeedTrackAsync(TrackPictures pictures, TrackAudio audio)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"track-{Guid.NewGuid():N}";
|
||||
var track = new Track
|
||||
[Fact]
|
||||
public async Task BuildAlbum_WithPendingPicture_OnlyRemovesTheOriginal()
|
||||
{
|
||||
Title = title,
|
||||
NormalizedTitle = title.ToUpperInvariant(),
|
||||
DurationSeconds = 10,
|
||||
OwnerUserId = user.Id,
|
||||
Pictures = pictures,
|
||||
Audio = audio
|
||||
};
|
||||
await database.Tracks.AddAsync(track, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return track;
|
||||
var album = await SeedAlbumAsync(EntityPictures.Pending("original.webp"));
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildAlbumAsync(album.Id, album.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[ActivityNames.MarkAlbumAsRemoving, ActivityNames.RemoveAlbumOriginalPicture, ActivityNames.DeleteAlbumFromDb],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildAlbum_MissingAlbum_OnlyMarksAndDeletes()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildAlbumAsync(Guid.NewGuid(), 1, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[ActivityNames.MarkAlbumAsRemoving, ActivityNames.DeleteAlbumFromDb],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildPlayList_WithoutPictures_OnlyMarksAndDeletes()
|
||||
{
|
||||
var playList = await SeedPlayListAsync(pictures: null);
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildPlayListAsync(playList.Id, playList.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[ActivityNames.MarkPlayListAsRemoving, ActivityNames.DeletePlayListFromDb],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildPlayList_WithPictures_RemovesThemBetweenMarkAndDelete()
|
||||
{
|
||||
var playList = await SeedPlayListAsync(new EntityPictures { OriginalName = "original.webp", SmallName = "small.webp" });
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildPlayListAsync(playList.Id, playList.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.MarkPlayListAsRemoving,
|
||||
ActivityNames.RemovePlayListOriginalPicture,
|
||||
ActivityNames.RemovePlayListSmallPicture,
|
||||
ActivityNames.DeletePlayListFromDb,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildTrack_Unprocessed_NeverRemovesTheSharedPresetPictures()
|
||||
{
|
||||
var track = await SeedTrackAsync(new TrackPictures { OriginalName = "original.webp", SmallName = "preset.webp" }, new TrackAudio { OriginalName = "audio.mp3" });
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildTrackAsync(track.Id, track.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.MarkTrackAsRemoving,
|
||||
ActivityNames.RemoveTrackOriginalPicture,
|
||||
ActivityNames.RemoveTrackOriginalAudio,
|
||||
ActivityNames.DeleteTrackFromDb,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BuildTrack_Processed_RemovesResizedPicturesAndProcessedAudio()
|
||||
{
|
||||
var track = await SeedTrackAsync(
|
||||
new TrackPictures
|
||||
{
|
||||
OriginalName = "original.webp",
|
||||
SmallName = "s.webp",
|
||||
MediumName = "m.webp",
|
||||
LargeName = "l.webp",
|
||||
ProcessingStatus = ProcessingStatus.Completed
|
||||
},
|
||||
new TrackAudio { OriginalName = "audio.mp3", FolderName = "folder", TranscodeStatus = ProcessingStatus.Completed });
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var slip = (await CreateBuilder(database).BuildTrackAsync(track.Id, track.OwnerUserId, null, Ct)).Build();
|
||||
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.MarkTrackAsRemoving,
|
||||
ActivityNames.RemoveTrackOriginalPicture,
|
||||
ActivityNames.RemoveTrackSmallPicture,
|
||||
ActivityNames.RemoveTrackMediumPicture,
|
||||
ActivityNames.RemoveTrackLargePicture,
|
||||
ActivityNames.RemoveTrackOriginalAudio,
|
||||
ActivityNames.RemoveTrackProcessedAudio,
|
||||
ActivityNames.DeleteTrackFromDb,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
}
|
||||
|
||||
private static DeleteRoutingSlipBuilder CreateBuilder(Musify.Application.Contracts.IDatabase database) =>
|
||||
new(
|
||||
database,
|
||||
new TrackConfiguration(),
|
||||
new AlbumConfiguration(),
|
||||
new PlayListConfiguration(),
|
||||
new ApplicationStorageConfiguration { Bucket = "bucket" });
|
||||
|
||||
private async Task<User> SeedUserAsync()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"delete-{Guid.NewGuid():N}"[..30];
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return user;
|
||||
}
|
||||
|
||||
private async Task<Album> SeedAlbumAsync(EntityPictures? pictures)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"album-{Guid.NewGuid():N}";
|
||||
var album = new Album { Title = title, NormalizedTitle = title.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
|
||||
await database.Albums.AddAsync(album, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return album;
|
||||
}
|
||||
|
||||
private async Task<PlayList> SeedPlayListAsync(EntityPictures? pictures)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"pl-{Guid.NewGuid():N}"[..30];
|
||||
var playList = new PlayList { Name = name, NormalizedName = name.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
|
||||
await database.PlayLists.AddAsync(playList, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return playList;
|
||||
}
|
||||
|
||||
private async Task<Track> SeedTrackAsync(TrackPictures pictures, TrackAudio audio)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"track-{Guid.NewGuid():N}";
|
||||
var track = new Track
|
||||
{
|
||||
Title = title,
|
||||
NormalizedTitle = title.ToUpperInvariant(),
|
||||
DurationSeconds = 10,
|
||||
OwnerUserId = user.Id,
|
||||
Pictures = pictures,
|
||||
Audio = audio
|
||||
};
|
||||
await database.Tracks.AddAsync(track, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return track;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,177 +9,178 @@ using Musify.Infrastructure.Tests.TestSupport;
|
||||
using NSubstitute;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.MassTransit;
|
||||
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class LifeCycleActivityTests(InfrastructureTestFixture fixture)
|
||||
namespace Musify.Infrastructure.Tests.MassTransit
|
||||
{
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
[Fact]
|
||||
public async Task MarkTrack_ExistingTrack_SetsTheStatus()
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class LifeCycleActivityTests(InfrastructureTestFixture fixture)
|
||||
{
|
||||
var track = await SeedTrackAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new MarkTrackLifeCycleActivity(database, NullLogger<MarkTrackLifeCycleActivity>.Instance);
|
||||
var context = ExecuteContextFor(new MarkLifeCycleArguments(track.Id, LifeCycleStatus.Removing));
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
await activity.Execute(context);
|
||||
|
||||
context.Received(1).Completed();
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct);
|
||||
Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MarkAlbum_ExistingAlbum_SetsTheStatus()
|
||||
{
|
||||
var album = await SeedAlbumAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new MarkAlbumLifeCycleActivity(database, NullLogger<MarkAlbumLifeCycleActivity>.Instance);
|
||||
|
||||
await activity.Execute(ExecuteContextFor(new MarkLifeCycleArguments(album.Id, LifeCycleStatus.Failed)));
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.Equal(LifeCycleStatus.Failed, (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).LifeCycleStatus);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MarkPlayList_ExistingPlayList_SetsTheStatus()
|
||||
{
|
||||
var playList = await SeedPlayListAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new MarkPlayListLifeCycleActivity(database, NullLogger<MarkPlayListLifeCycleActivity>.Instance);
|
||||
|
||||
await activity.Execute(ExecuteContextFor(new MarkLifeCycleArguments(playList.Id, LifeCycleStatus.Removing)));
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.Equal(LifeCycleStatus.Removing, (await verifier.PlayLists.AsNoTracking().SingleAsync(p => p.Id == playList.Id, Ct)).LifeCycleStatus);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Mark_MissingEntity_CompletesWithoutFailing()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new MarkTrackLifeCycleActivity(database, NullLogger<MarkTrackLifeCycleActivity>.Instance);
|
||||
var context = ExecuteContextFor(new MarkLifeCycleArguments(Guid.NewGuid(), LifeCycleStatus.Failed));
|
||||
|
||||
await activity.Execute(context);
|
||||
|
||||
context.Received(1).Completed();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteTrack_ExistingTrack_RemovesTheRow()
|
||||
{
|
||||
var track = await SeedTrackAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new DeleteTrackActivity(database, NullLogger<DeleteTrackActivity>.Instance);
|
||||
var context = ExecuteContextFor(new DeleteEntityArguments(track.Id));
|
||||
|
||||
await activity.Execute(context);
|
||||
|
||||
context.Received(1).Completed();
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.Tracks.AnyAsync(t => t.Id == track.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteAlbum_ExistingAlbum_RemovesTheRow()
|
||||
{
|
||||
var album = await SeedAlbumAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new DeleteAlbumActivity(database, NullLogger<DeleteAlbumActivity>.Instance);
|
||||
|
||||
await activity.Execute(ExecuteContextFor(new DeleteEntityArguments(album.Id)));
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.Albums.AnyAsync(a => a.Id == album.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeletePlayList_ExistingPlayList_RemovesTheRow()
|
||||
{
|
||||
var playList = await SeedPlayListAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new DeletePlayListActivity(database, NullLogger<DeletePlayListActivity>.Instance);
|
||||
|
||||
await activity.Execute(ExecuteContextFor(new DeleteEntityArguments(playList.Id)));
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.PlayLists.AnyAsync(p => p.Id == playList.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Delete_MissingEntity_CompletesWithoutFailing()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new DeleteTrackActivity(database, NullLogger<DeleteTrackActivity>.Instance);
|
||||
var context = ExecuteContextFor(new DeleteEntityArguments(Guid.NewGuid()));
|
||||
|
||||
await activity.Execute(context);
|
||||
|
||||
context.Received(1).Completed();
|
||||
}
|
||||
|
||||
private static ExecuteContext<TArguments> ExecuteContextFor<TArguments>(TArguments arguments)
|
||||
where TArguments : class
|
||||
{
|
||||
var context = Substitute.For<ExecuteContext<TArguments>>();
|
||||
context.Arguments.Returns(arguments);
|
||||
context.CancellationToken.Returns(Ct);
|
||||
return context;
|
||||
}
|
||||
|
||||
private async Task<User> SeedUserAsync()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"lifecycle-{Guid.NewGuid():N}"[..30];
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return user;
|
||||
}
|
||||
|
||||
private async Task<Track> SeedTrackAsync()
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"track-{Guid.NewGuid():N}";
|
||||
var track = new Track
|
||||
[Fact]
|
||||
public async Task MarkTrack_ExistingTrack_SetsTheStatus()
|
||||
{
|
||||
Title = title,
|
||||
NormalizedTitle = title.ToUpperInvariant(),
|
||||
DurationSeconds = 10,
|
||||
OwnerUserId = user.Id,
|
||||
Pictures = new TrackPictures(),
|
||||
Audio = new TrackAudio()
|
||||
};
|
||||
await database.Tracks.AddAsync(track, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return track;
|
||||
}
|
||||
var track = await SeedTrackAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new MarkTrackLifeCycleActivity(database, NullLogger<MarkTrackLifeCycleActivity>.Instance);
|
||||
var context = ExecuteContextFor(new MarkLifeCycleArguments(track.Id, LifeCycleStatus.Removing));
|
||||
|
||||
private async Task<Album> SeedAlbumAsync()
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"album-{Guid.NewGuid():N}";
|
||||
var album = new Album { Title = title, NormalizedTitle = title.ToUpperInvariant(), OwnerUserId = user.Id };
|
||||
await database.Albums.AddAsync(album, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return album;
|
||||
}
|
||||
await activity.Execute(context);
|
||||
|
||||
private async Task<PlayList> SeedPlayListAsync()
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"pl-{Guid.NewGuid():N}"[..30];
|
||||
var playList = new PlayList { Name = name, NormalizedName = name.ToUpperInvariant(), OwnerUserId = user.Id };
|
||||
await database.PlayLists.AddAsync(playList, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return playList;
|
||||
context.Received(1).Completed();
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct);
|
||||
Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MarkAlbum_ExistingAlbum_SetsTheStatus()
|
||||
{
|
||||
var album = await SeedAlbumAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new MarkAlbumLifeCycleActivity(database, NullLogger<MarkAlbumLifeCycleActivity>.Instance);
|
||||
|
||||
await activity.Execute(ExecuteContextFor(new MarkLifeCycleArguments(album.Id, LifeCycleStatus.Failed)));
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.Equal(LifeCycleStatus.Failed, (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).LifeCycleStatus);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MarkPlayList_ExistingPlayList_SetsTheStatus()
|
||||
{
|
||||
var playList = await SeedPlayListAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new MarkPlayListLifeCycleActivity(database, NullLogger<MarkPlayListLifeCycleActivity>.Instance);
|
||||
|
||||
await activity.Execute(ExecuteContextFor(new MarkLifeCycleArguments(playList.Id, LifeCycleStatus.Removing)));
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.Equal(LifeCycleStatus.Removing, (await verifier.PlayLists.AsNoTracking().SingleAsync(p => p.Id == playList.Id, Ct)).LifeCycleStatus);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Mark_MissingEntity_CompletesWithoutFailing()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new MarkTrackLifeCycleActivity(database, NullLogger<MarkTrackLifeCycleActivity>.Instance);
|
||||
var context = ExecuteContextFor(new MarkLifeCycleArguments(Guid.NewGuid(), LifeCycleStatus.Failed));
|
||||
|
||||
await activity.Execute(context);
|
||||
|
||||
context.Received(1).Completed();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteTrack_ExistingTrack_RemovesTheRow()
|
||||
{
|
||||
var track = await SeedTrackAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new DeleteTrackActivity(database, NullLogger<DeleteTrackActivity>.Instance);
|
||||
var context = ExecuteContextFor(new DeleteEntityArguments(track.Id));
|
||||
|
||||
await activity.Execute(context);
|
||||
|
||||
context.Received(1).Completed();
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.Tracks.AnyAsync(t => t.Id == track.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteAlbum_ExistingAlbum_RemovesTheRow()
|
||||
{
|
||||
var album = await SeedAlbumAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new DeleteAlbumActivity(database, NullLogger<DeleteAlbumActivity>.Instance);
|
||||
|
||||
await activity.Execute(ExecuteContextFor(new DeleteEntityArguments(album.Id)));
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.Albums.AnyAsync(a => a.Id == album.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeletePlayList_ExistingPlayList_RemovesTheRow()
|
||||
{
|
||||
var playList = await SeedPlayListAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new DeletePlayListActivity(database, NullLogger<DeletePlayListActivity>.Instance);
|
||||
|
||||
await activity.Execute(ExecuteContextFor(new DeleteEntityArguments(playList.Id)));
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.PlayLists.AnyAsync(p => p.Id == playList.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Delete_MissingEntity_CompletesWithoutFailing()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var activity = new DeleteTrackActivity(database, NullLogger<DeleteTrackActivity>.Instance);
|
||||
var context = ExecuteContextFor(new DeleteEntityArguments(Guid.NewGuid()));
|
||||
|
||||
await activity.Execute(context);
|
||||
|
||||
context.Received(1).Completed();
|
||||
}
|
||||
|
||||
private static ExecuteContext<TArguments> ExecuteContextFor<TArguments>(TArguments arguments)
|
||||
where TArguments : class
|
||||
{
|
||||
var context = Substitute.For<ExecuteContext<TArguments>>();
|
||||
context.Arguments.Returns(arguments);
|
||||
context.CancellationToken.Returns(Ct);
|
||||
return context;
|
||||
}
|
||||
|
||||
private async Task<User> SeedUserAsync()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"lifecycle-{Guid.NewGuid():N}"[..30];
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return user;
|
||||
}
|
||||
|
||||
private async Task<Track> SeedTrackAsync()
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"track-{Guid.NewGuid():N}";
|
||||
var track = new Track
|
||||
{
|
||||
Title = title,
|
||||
NormalizedTitle = title.ToUpperInvariant(),
|
||||
DurationSeconds = 10,
|
||||
OwnerUserId = user.Id,
|
||||
Pictures = new TrackPictures(),
|
||||
Audio = new TrackAudio()
|
||||
};
|
||||
await database.Tracks.AddAsync(track, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return track;
|
||||
}
|
||||
|
||||
private async Task<Album> SeedAlbumAsync()
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"album-{Guid.NewGuid():N}";
|
||||
var album = new Album { Title = title, NormalizedTitle = title.ToUpperInvariant(), OwnerUserId = user.Id };
|
||||
await database.Albums.AddAsync(album, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return album;
|
||||
}
|
||||
|
||||
private async Task<PlayList> SeedPlayListAsync()
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"pl-{Guid.NewGuid():N}"[..30];
|
||||
var playList = new PlayList { Name = name, NormalizedName = name.ToUpperInvariant(), OwnerUserId = user.Id };
|
||||
await database.PlayLists.AddAsync(playList, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return playList;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+94
-93
@@ -7,102 +7,103 @@ using Musify.Infrastructure.MassTransit.Consumers;
|
||||
using Musify.Infrastructure.MassTransit.RoutingSlip;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.MassTransit;
|
||||
|
||||
public sealed class ProcessingSlipFaultConsumerTests
|
||||
namespace Musify.Infrastructure.Tests.MassTransit
|
||||
{
|
||||
private static readonly Guid SubjectId = Guid.NewGuid();
|
||||
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_TrackPicture_PublishesTrackPictureProcessingFailed() =>
|
||||
await AssertPublishedAsync<TrackPictureProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.TrackPicture, message => message.TrackId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_TrackAudio_PublishesTrackAudioProcessingFailed() =>
|
||||
await AssertPublishedAsync<TrackAudioProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.TrackAudio, message => message.TrackId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_PlayListPicture_PublishesPlayListPictureProcessingFailed() =>
|
||||
await AssertPublishedAsync<PlayListPictureProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.PlayListPicture, message => message.PlayListId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_AlbumPicture_PublishesAlbumPictureProcessingFailed() =>
|
||||
await AssertPublishedAsync<AlbumPictureProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.AlbumPicture, message => message.AlbumId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_TrackCreation_PublishesTrackProcessingFailedWithKeys() =>
|
||||
await AssertPublishedAsync<TrackProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.TrackCreation,
|
||||
message => message is { Bucket: "bucket", PictureKey: "picture-key", AudioKey: "audio-key" } && message.TrackId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_AlbumCreation_PublishesAlbumProcessingFailedWithKeys() =>
|
||||
await AssertPublishedAsync<AlbumProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.AlbumCreation,
|
||||
message => message is { Bucket: "bucket", PictureKey: "picture-key" } && message.AlbumId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_PlayListCreation_PublishesPlayListProcessingFailedWithKeys() =>
|
||||
await AssertPublishedAsync<PlayListProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.PlayListCreation,
|
||||
message => message is { Bucket: "bucket", PictureKey: "picture-key" } && message.PlayListId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_UnknownKind_PublishesNothing()
|
||||
public sealed class ProcessingSlipFaultConsumerTests
|
||||
{
|
||||
await using var provider = CreateProvider();
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
private static readonly Guid SubjectId = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = Variables("Something else") }, Ct);
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
Assert.True(await harness.Consumed.Any<RoutingSlipFaulted>(Ct));
|
||||
Assert.False(await harness.Published.Any<TrackPictureProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<TrackProcessingFailed>(Ct));
|
||||
[Fact]
|
||||
public async Task Consume_TrackPicture_PublishesTrackPictureProcessingFailed() =>
|
||||
await AssertPublishedAsync<TrackPictureProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.TrackPicture, message => message.TrackId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_TrackAudio_PublishesTrackAudioProcessingFailed() =>
|
||||
await AssertPublishedAsync<TrackAudioProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.TrackAudio, message => message.TrackId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_PlayListPicture_PublishesPlayListPictureProcessingFailed() =>
|
||||
await AssertPublishedAsync<PlayListPictureProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.PlayListPicture, message => message.PlayListId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_AlbumPicture_PublishesAlbumPictureProcessingFailed() =>
|
||||
await AssertPublishedAsync<AlbumPictureProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.AlbumPicture, message => message.AlbumId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_TrackCreation_PublishesTrackProcessingFailedWithKeys() =>
|
||||
await AssertPublishedAsync<TrackProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.TrackCreation,
|
||||
message => message is { Bucket: "bucket", PictureKey: "picture-key", AudioKey: "audio-key" } && message.TrackId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_AlbumCreation_PublishesAlbumProcessingFailedWithKeys() =>
|
||||
await AssertPublishedAsync<AlbumProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.AlbumCreation,
|
||||
message => message is { Bucket: "bucket", PictureKey: "picture-key" } && message.AlbumId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_PlayListCreation_PublishesPlayListProcessingFailedWithKeys() =>
|
||||
await AssertPublishedAsync<PlayListProcessingFailed>(
|
||||
RoutingSlipVariableNames.ProcessKinds.PlayListCreation,
|
||||
message => message is { Bucket: "bucket", PictureKey: "picture-key" } && message.PlayListId == SubjectId);
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_UnknownKind_PublishesNothing()
|
||||
{
|
||||
await using var provider = CreateProvider();
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
|
||||
await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = Variables("Something else") }, Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<RoutingSlipFaulted>(Ct));
|
||||
Assert.False(await harness.Published.Any<TrackPictureProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<TrackProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_WithoutProcessKind_PublishesNothing()
|
||||
{
|
||||
await using var provider = CreateProvider();
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
|
||||
await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = new Dictionary<string, object>() }, Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<RoutingSlipFaulted>(Ct));
|
||||
Assert.False(await harness.Published.Any<TrackPictureProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
private static async Task AssertPublishedAsync<TEvent>(string processKind, Func<TEvent, bool> matches)
|
||||
where TEvent : class
|
||||
{
|
||||
await using var provider = CreateProvider();
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
|
||||
await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = Variables(processKind) }, Ct);
|
||||
|
||||
Assert.True(await harness.Published.Any<TEvent>(published => matches(published.Context.Message), Ct));
|
||||
}
|
||||
|
||||
private static Dictionary<string, object> Variables(string processKind) => new()
|
||||
{
|
||||
[RoutingSlipVariableNames.Workflow.ProcessKind] = processKind,
|
||||
[RoutingSlipVariableNames.Workflow.SubjectId] = SubjectId,
|
||||
[RoutingSlipVariableNames.Workflow.Bucket] = "bucket",
|
||||
[RoutingSlipVariableNames.Workflow.PictureKey] = "picture-key",
|
||||
[RoutingSlipVariableNames.Workflow.AudioKey] = "audio-key",
|
||||
};
|
||||
|
||||
private static ServiceProvider CreateProvider() =>
|
||||
new ServiceCollection()
|
||||
.AddMassTransitTestHarness(bus => bus.AddConsumer<ProcessingSlipFaultConsumer>())
|
||||
.BuildServiceProvider(true);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Consume_WithoutProcessKind_PublishesNothing()
|
||||
{
|
||||
await using var provider = CreateProvider();
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
|
||||
await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = new Dictionary<string, object>() }, Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<RoutingSlipFaulted>(Ct));
|
||||
Assert.False(await harness.Published.Any<TrackPictureProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
private static async Task AssertPublishedAsync<TEvent>(string processKind, Func<TEvent, bool> matches)
|
||||
where TEvent : class
|
||||
{
|
||||
await using var provider = CreateProvider();
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
|
||||
await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = Variables(processKind) }, Ct);
|
||||
|
||||
Assert.True(await harness.Published.Any<TEvent>(published => matches(published.Context.Message), Ct));
|
||||
}
|
||||
|
||||
private static Dictionary<string, object> Variables(string processKind) => new()
|
||||
{
|
||||
[RoutingSlipVariableNames.Workflow.ProcessKind] = processKind,
|
||||
[RoutingSlipVariableNames.Workflow.SubjectId] = SubjectId,
|
||||
[RoutingSlipVariableNames.Workflow.Bucket] = "bucket",
|
||||
[RoutingSlipVariableNames.Workflow.PictureKey] = "picture-key",
|
||||
[RoutingSlipVariableNames.Workflow.AudioKey] = "audio-key",
|
||||
};
|
||||
|
||||
private static ServiceProvider CreateProvider() =>
|
||||
new ServiceCollection()
|
||||
.AddMassTransitTestHarness(bus => bus.AddConsumer<ProcessingSlipFaultConsumer>())
|
||||
.BuildServiceProvider(true);
|
||||
}
|
||||
|
||||
+193
-192
@@ -6,202 +6,203 @@ using Musify.Application.Shared;
|
||||
using Musify.Infrastructure.MassTransit.Sagas;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.MassTransit;
|
||||
|
||||
public sealed class ProcessingStateMachineTests
|
||||
namespace Musify.Infrastructure.Tests.MassTransit
|
||||
{
|
||||
private static readonly ImageSizes Sizes = new(new ImageSize("s", 1, 1), new ImageSize("m", 2, 2), new ImageSize("l", 3, 3));
|
||||
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
// Track
|
||||
|
||||
[Fact]
|
||||
public async Task Track_PictureAndAudioProcessed_CompletesTheSaga()
|
||||
public sealed class ProcessingStateMachineTests
|
||||
{
|
||||
await using var provider = CreateProvider<TrackProcessingStateMachine, TrackProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<TrackProcessingStateMachine, TrackProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
private static readonly ImageSizes Sizes = new(new ImageSize("s", 1, 1), new ImageSize("m", 2, 2), new ImageSize("l", 3, 3));
|
||||
|
||||
await harness.Bus.Publish(TrackStarted(id), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
await harness.Bus.Publish(new TrackPictureProcessed(id), Ct);
|
||||
await harness.Bus.Publish(new TrackAudioProcessed(id), Ct);
|
||||
// Track
|
||||
|
||||
Assert.Null(await saga.NotExists(id));
|
||||
Assert.False(await harness.Published.Any<TrackProcessingFailed>(Ct));
|
||||
[Fact]
|
||||
public async Task Track_PictureAndAudioProcessed_CompletesTheSaga()
|
||||
{
|
||||
await using var provider = CreateProvider<TrackProcessingStateMachine, TrackProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<TrackProcessingStateMachine, TrackProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(TrackStarted(id), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new TrackPictureProcessed(id), Ct);
|
||||
await harness.Bus.Publish(new TrackAudioProcessed(id), Ct);
|
||||
|
||||
Assert.Null(await saga.NotExists(id));
|
||||
Assert.False(await harness.Published.Any<TrackProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Track_PictureFailed_PublishesProcessingFailedAndMovesToFailed()
|
||||
{
|
||||
await using var provider = CreateProvider<TrackProcessingStateMachine, TrackProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<TrackProcessingStateMachine, TrackProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(TrackStarted(id), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new TrackPictureProcessingFailed(id), Ct);
|
||||
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Failed));
|
||||
Assert.True(await harness.Published.Any<TrackProcessingFailed>(
|
||||
published => published.Context.Message is { Bucket: "bucket", PictureKey: "picture", AudioKey: "audio" }
|
||||
&& published.Context.Message.TrackId == id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Track_AudioFailed_PublishesProcessingFailed()
|
||||
{
|
||||
await using var provider = CreateProvider<TrackProcessingStateMachine, TrackProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<TrackProcessingStateMachine, TrackProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(TrackStarted(id), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new TrackAudioProcessingFailed(id), Ct);
|
||||
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Failed));
|
||||
Assert.True(await harness.Published.Any<TrackProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Track_EventForMissingInstance_IsDiscarded()
|
||||
{
|
||||
await using var provider = CreateProvider<TrackProcessingStateMachine, TrackProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new TrackPictureProcessed(id), Ct);
|
||||
await harness.Bus.Publish(new TrackAudioProcessingFailed(id), Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<TrackAudioProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<Fault<TrackPictureProcessed>>(Ct));
|
||||
Assert.False(await harness.Published.Any<Fault<TrackAudioProcessingFailed>>(Ct));
|
||||
Assert.False(await harness.Published.Any<TrackProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
// Album
|
||||
|
||||
[Fact]
|
||||
public async Task Album_PictureProcessed_CompletesTheSaga()
|
||||
{
|
||||
await using var provider = CreateProvider<AlbumProcessingStateMachine, AlbumProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<AlbumProcessingStateMachine, AlbumProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new CreateAlbumResourcesEvent(id, Guid.NewGuid(), "bucket", "source", "picture", Sizes), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new AlbumPictureProcessed(id), Ct);
|
||||
|
||||
Assert.Null(await saga.NotExists(id));
|
||||
Assert.False(await harness.Published.Any<AlbumProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Album_PictureFailed_PublishesProcessingFailed()
|
||||
{
|
||||
await using var provider = CreateProvider<AlbumProcessingStateMachine, AlbumProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<AlbumProcessingStateMachine, AlbumProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new CreateAlbumResourcesEvent(id, Guid.NewGuid(), "bucket", "source", "picture", Sizes), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new AlbumPictureProcessingFailed(id), Ct);
|
||||
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Failed));
|
||||
Assert.True(await harness.Published.Any<AlbumProcessingFailed>(
|
||||
published => published.Context.Message is { Bucket: "bucket", PictureKey: "picture" }
|
||||
&& published.Context.Message.AlbumId == id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Album_EventForMissingInstance_IsDiscarded()
|
||||
{
|
||||
await using var provider = CreateProvider<AlbumProcessingStateMachine, AlbumProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
await harness.Bus.Publish(new AlbumPictureProcessingFailed(Guid.NewGuid()), Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<AlbumPictureProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<AlbumProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<Fault<AlbumPictureProcessingFailed>>(Ct));
|
||||
}
|
||||
|
||||
// PlayList
|
||||
|
||||
[Fact]
|
||||
public async Task PlayList_PictureProcessed_CompletesTheSaga()
|
||||
{
|
||||
await using var provider = CreateProvider<PlayListProcessingStateMachine, PlayListProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<PlayListProcessingStateMachine, PlayListProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new CreatePlayListResourcesEvent(id, Guid.NewGuid(), "bucket", "source", "picture", Sizes), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new PlayListPictureProcessed(id), Ct);
|
||||
|
||||
Assert.Null(await saga.NotExists(id));
|
||||
Assert.False(await harness.Published.Any<PlayListProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PlayList_PictureFailed_PublishesProcessingFailed()
|
||||
{
|
||||
await using var provider = CreateProvider<PlayListProcessingStateMachine, PlayListProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<PlayListProcessingStateMachine, PlayListProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new CreatePlayListResourcesEvent(id, Guid.NewGuid(), "bucket", "source", "picture", Sizes), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new PlayListPictureProcessingFailed(id), Ct);
|
||||
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Failed));
|
||||
Assert.True(await harness.Published.Any<PlayListProcessingFailed>(
|
||||
published => published.Context.Message is { Bucket: "bucket", PictureKey: "picture" }
|
||||
&& published.Context.Message.PlayListId == id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PlayList_EventForMissingInstance_IsDiscarded()
|
||||
{
|
||||
await using var provider = CreateProvider<PlayListProcessingStateMachine, PlayListProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
await harness.Bus.Publish(new PlayListPictureProcessingFailed(Guid.NewGuid()), Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<PlayListPictureProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<PlayListProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<Fault<PlayListPictureProcessingFailed>>(Ct));
|
||||
}
|
||||
|
||||
private static CreateTrackResourcesEvent TrackStarted(Guid id) =>
|
||||
new(id, Guid.NewGuid(), Guid.NewGuid(), "bucket", "picture-source", "picture", "audio-source", "audio", "audio-folder", Sizes);
|
||||
|
||||
private static async Task<ITestHarness> StartAsync(ServiceProvider provider)
|
||||
{
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
return harness;
|
||||
}
|
||||
|
||||
private static ServiceProvider CreateProvider<TMachine, TState>()
|
||||
where TMachine : class, SagaStateMachine<TState>
|
||||
where TState : class, SagaStateMachineInstance =>
|
||||
new ServiceCollection()
|
||||
.AddMassTransitTestHarness(bus => bus.AddSagaStateMachine<TMachine, TState>().InMemoryRepository())
|
||||
.BuildServiceProvider(true);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Track_PictureFailed_PublishesProcessingFailedAndMovesToFailed()
|
||||
{
|
||||
await using var provider = CreateProvider<TrackProcessingStateMachine, TrackProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<TrackProcessingStateMachine, TrackProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(TrackStarted(id), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new TrackPictureProcessingFailed(id), Ct);
|
||||
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Failed));
|
||||
Assert.True(await harness.Published.Any<TrackProcessingFailed>(
|
||||
published => published.Context.Message is { Bucket: "bucket", PictureKey: "picture", AudioKey: "audio" }
|
||||
&& published.Context.Message.TrackId == id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Track_AudioFailed_PublishesProcessingFailed()
|
||||
{
|
||||
await using var provider = CreateProvider<TrackProcessingStateMachine, TrackProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<TrackProcessingStateMachine, TrackProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(TrackStarted(id), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new TrackAudioProcessingFailed(id), Ct);
|
||||
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Failed));
|
||||
Assert.True(await harness.Published.Any<TrackProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Track_EventForMissingInstance_IsDiscarded()
|
||||
{
|
||||
await using var provider = CreateProvider<TrackProcessingStateMachine, TrackProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new TrackPictureProcessed(id), Ct);
|
||||
await harness.Bus.Publish(new TrackAudioProcessingFailed(id), Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<TrackAudioProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<Fault<TrackPictureProcessed>>(Ct));
|
||||
Assert.False(await harness.Published.Any<Fault<TrackAudioProcessingFailed>>(Ct));
|
||||
Assert.False(await harness.Published.Any<TrackProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
// Album
|
||||
|
||||
[Fact]
|
||||
public async Task Album_PictureProcessed_CompletesTheSaga()
|
||||
{
|
||||
await using var provider = CreateProvider<AlbumProcessingStateMachine, AlbumProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<AlbumProcessingStateMachine, AlbumProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new CreateAlbumResourcesEvent(id, Guid.NewGuid(), "bucket", "source", "picture", Sizes), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new AlbumPictureProcessed(id), Ct);
|
||||
|
||||
Assert.Null(await saga.NotExists(id));
|
||||
Assert.False(await harness.Published.Any<AlbumProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Album_PictureFailed_PublishesProcessingFailed()
|
||||
{
|
||||
await using var provider = CreateProvider<AlbumProcessingStateMachine, AlbumProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<AlbumProcessingStateMachine, AlbumProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new CreateAlbumResourcesEvent(id, Guid.NewGuid(), "bucket", "source", "picture", Sizes), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new AlbumPictureProcessingFailed(id), Ct);
|
||||
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Failed));
|
||||
Assert.True(await harness.Published.Any<AlbumProcessingFailed>(
|
||||
published => published.Context.Message is { Bucket: "bucket", PictureKey: "picture" }
|
||||
&& published.Context.Message.AlbumId == id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Album_EventForMissingInstance_IsDiscarded()
|
||||
{
|
||||
await using var provider = CreateProvider<AlbumProcessingStateMachine, AlbumProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
await harness.Bus.Publish(new AlbumPictureProcessingFailed(Guid.NewGuid()), Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<AlbumPictureProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<AlbumProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<Fault<AlbumPictureProcessingFailed>>(Ct));
|
||||
}
|
||||
|
||||
// PlayList
|
||||
|
||||
[Fact]
|
||||
public async Task PlayList_PictureProcessed_CompletesTheSaga()
|
||||
{
|
||||
await using var provider = CreateProvider<PlayListProcessingStateMachine, PlayListProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<PlayListProcessingStateMachine, PlayListProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new CreatePlayListResourcesEvent(id, Guid.NewGuid(), "bucket", "source", "picture", Sizes), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new PlayListPictureProcessed(id), Ct);
|
||||
|
||||
Assert.Null(await saga.NotExists(id));
|
||||
Assert.False(await harness.Published.Any<PlayListProcessingFailed>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PlayList_PictureFailed_PublishesProcessingFailed()
|
||||
{
|
||||
await using var provider = CreateProvider<PlayListProcessingStateMachine, PlayListProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
var saga = provider.GetRequiredService<ISagaStateMachineTestHarness<PlayListProcessingStateMachine, PlayListProcessingState>>();
|
||||
var id = Guid.NewGuid();
|
||||
|
||||
await harness.Bus.Publish(new CreatePlayListResourcesEvent(id, Guid.NewGuid(), "bucket", "source", "picture", Sizes), Ct);
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Processing));
|
||||
|
||||
await harness.Bus.Publish(new PlayListPictureProcessingFailed(id), Ct);
|
||||
|
||||
Assert.NotNull(await saga.Exists(id, machine => machine.Failed));
|
||||
Assert.True(await harness.Published.Any<PlayListProcessingFailed>(
|
||||
published => published.Context.Message is { Bucket: "bucket", PictureKey: "picture" }
|
||||
&& published.Context.Message.PlayListId == id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PlayList_EventForMissingInstance_IsDiscarded()
|
||||
{
|
||||
await using var provider = CreateProvider<PlayListProcessingStateMachine, PlayListProcessingState>();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
await harness.Bus.Publish(new PlayListPictureProcessingFailed(Guid.NewGuid()), Ct);
|
||||
|
||||
Assert.True(await harness.Consumed.Any<PlayListPictureProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<PlayListProcessingFailed>(Ct));
|
||||
Assert.False(await harness.Published.Any<Fault<PlayListPictureProcessingFailed>>(Ct));
|
||||
}
|
||||
|
||||
private static CreateTrackResourcesEvent TrackStarted(Guid id) =>
|
||||
new(id, Guid.NewGuid(), Guid.NewGuid(), "bucket", "picture-source", "picture", "audio-source", "audio", "audio-folder", Sizes);
|
||||
|
||||
private static async Task<ITestHarness> StartAsync(ServiceProvider provider)
|
||||
{
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
return harness;
|
||||
}
|
||||
|
||||
private static ServiceProvider CreateProvider<TMachine, TState>()
|
||||
where TMachine : class, SagaStateMachine<TState>
|
||||
where TState : class, SagaStateMachineInstance =>
|
||||
new ServiceCollection()
|
||||
.AddMassTransitTestHarness(bus => bus.AddSagaStateMachine<TMachine, TState>().InMemoryRepository())
|
||||
.BuildServiceProvider(true);
|
||||
}
|
||||
|
||||
@@ -7,123 +7,124 @@ using Musify.Infrastructure.MassTransit.RoutingSlip;
|
||||
using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.MassTransit;
|
||||
|
||||
public sealed class RoutingSlipBuilderTests
|
||||
namespace Musify.Infrastructure.Tests.MassTransit
|
||||
{
|
||||
private static readonly ImageSizes Sizes = new(new ImageSize("s", 1, 1), new ImageSize("m", 2, 2), new ImageSize("l", 3, 3));
|
||||
|
||||
private static readonly Guid SubjectId = Guid.NewGuid();
|
||||
private static readonly Guid IntentId = Guid.NewGuid();
|
||||
private static readonly Guid CorrelationId = Guid.NewGuid();
|
||||
|
||||
[Fact]
|
||||
public void Create_AlwaysSubscribesTheCleanUpConsumerAndCarriesTheCorrelationId()
|
||||
public sealed class RoutingSlipBuilderTests
|
||||
{
|
||||
var slip = RoutingSlips.Create(CorrelationId).Build();
|
||||
private static readonly ImageSizes Sizes = new(new ImageSize("s", 1, 1), new ImageSize("m", 2, 2), new ImageSize("l", 3, 3));
|
||||
|
||||
Assert.Equal(CorrelationId, slip.Variables[RoutingSlipVariableNames.Workflow.CorrelationId]);
|
||||
var subscription = Assert.Single(slip.Subscriptions);
|
||||
Assert.Equal(RoutingSlips.ConsumerUri(RoutingSlipCleanUpConsumer.QueueName), subscription.Address);
|
||||
Assert.Equal(RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted, subscription.Events);
|
||||
}
|
||||
private static readonly Guid SubjectId = Guid.NewGuid();
|
||||
private static readonly Guid IntentId = Guid.NewGuid();
|
||||
private static readonly Guid CorrelationId = Guid.NewGuid();
|
||||
|
||||
[Fact]
|
||||
public void Create_WithoutCorrelationId_UsesEmptyGuid()
|
||||
{
|
||||
var slip = RoutingSlips.Create(null).Build();
|
||||
[Fact]
|
||||
public void Create_AlwaysSubscribesTheCleanUpConsumerAndCarriesTheCorrelationId()
|
||||
{
|
||||
var slip = RoutingSlips.Create(CorrelationId).Build();
|
||||
|
||||
Assert.Equal(Guid.Empty, slip.Variables[RoutingSlipVariableNames.Workflow.CorrelationId]);
|
||||
}
|
||||
Assert.Equal(CorrelationId, slip.Variables[RoutingSlipVariableNames.Workflow.CorrelationId]);
|
||||
var subscription = Assert.Single(slip.Subscriptions);
|
||||
Assert.Equal(RoutingSlips.ConsumerUri(RoutingSlipCleanUpConsumer.QueueName), subscription.Address);
|
||||
Assert.Equal(RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted, subscription.Events);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrackFaults_AddsSubjectProcessKindAndFaultSubscription()
|
||||
{
|
||||
var slip = RoutingSlips.Create(null).TrackFaults(SubjectId, "Kind").Build();
|
||||
[Fact]
|
||||
public void Create_WithoutCorrelationId_UsesEmptyGuid()
|
||||
{
|
||||
var slip = RoutingSlips.Create(null).Build();
|
||||
|
||||
Assert.Equal(SubjectId, slip.Variables[RoutingSlipVariableNames.Workflow.SubjectId]);
|
||||
Assert.Equal("Kind", slip.Variables[RoutingSlipVariableNames.Workflow.ProcessKind]);
|
||||
Assert.Contains(slip.Subscriptions, subscription =>
|
||||
subscription.Address == RoutingSlips.ConsumerUri(ProcessingSlipFaultConsumer.QueueName)
|
||||
&& subscription.Events == RoutingSlipEvents.Faulted);
|
||||
}
|
||||
Assert.Equal(Guid.Empty, slip.Variables[RoutingSlipVariableNames.Workflow.CorrelationId]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PictureSource_CreateAlbum_CopiesConsumesAndPublishesInOrder()
|
||||
{
|
||||
var message = new CreateAlbumResourcesEvent(SubjectId, IntentId, "bucket", "source-key", "final-key", Sizes);
|
||||
[Fact]
|
||||
public void TrackFaults_AddsSubjectProcessKindAndFaultSubscription()
|
||||
{
|
||||
var slip = RoutingSlips.Create(null).TrackFaults(SubjectId, "Kind").Build();
|
||||
|
||||
var slip = new PictureSourceRoutingSlipBuilder().Build(message, CorrelationId).Build();
|
||||
Assert.Equal(SubjectId, slip.Variables[RoutingSlipVariableNames.Workflow.SubjectId]);
|
||||
Assert.Equal("Kind", slip.Variables[RoutingSlipVariableNames.Workflow.ProcessKind]);
|
||||
Assert.Contains(slip.Subscriptions, subscription =>
|
||||
subscription.Address == RoutingSlips.ConsumerUri(ProcessingSlipFaultConsumer.QueueName)
|
||||
&& subscription.Events == RoutingSlipEvents.Faulted);
|
||||
}
|
||||
|
||||
AssertPictureSourceSlip(slip, RoutingSlipVariableNames.ProcessKinds.AlbumCreation, ActivityNames.PublishAlbumPictureProcessingEvent);
|
||||
}
|
||||
[Fact]
|
||||
public void PictureSource_CreateAlbum_CopiesConsumesAndPublishesInOrder()
|
||||
{
|
||||
var message = new CreateAlbumResourcesEvent(SubjectId, IntentId, "bucket", "source-key", "final-key", Sizes);
|
||||
|
||||
[Fact]
|
||||
public void PictureSource_UpdateAlbum_UsesTheAlbumPictureProcessKind()
|
||||
{
|
||||
var message = new UpdateAlbumPictureSourceEvent(SubjectId, IntentId, "bucket", "source-key", "final-key", Sizes);
|
||||
var slip = new PictureSourceRoutingSlipBuilder().Build(message, CorrelationId).Build();
|
||||
|
||||
var slip = new PictureSourceRoutingSlipBuilder().Build(message, CorrelationId).Build();
|
||||
AssertPictureSourceSlip(slip, RoutingSlipVariableNames.ProcessKinds.AlbumCreation, ActivityNames.PublishAlbumPictureProcessingEvent);
|
||||
}
|
||||
|
||||
AssertPictureSourceSlip(slip, RoutingSlipVariableNames.ProcessKinds.AlbumPicture, ActivityNames.PublishAlbumPictureProcessingEvent);
|
||||
}
|
||||
[Fact]
|
||||
public void PictureSource_UpdateAlbum_UsesTheAlbumPictureProcessKind()
|
||||
{
|
||||
var message = new UpdateAlbumPictureSourceEvent(SubjectId, IntentId, "bucket", "source-key", "final-key", Sizes);
|
||||
|
||||
[Fact]
|
||||
public void PictureSource_CreatePlayList_CopiesConsumesAndPublishesInOrder()
|
||||
{
|
||||
var message = new CreatePlayListResourcesEvent(SubjectId, IntentId, "bucket", "source-key", "final-key", Sizes);
|
||||
var slip = new PictureSourceRoutingSlipBuilder().Build(message, CorrelationId).Build();
|
||||
|
||||
var slip = new PictureSourceRoutingSlipBuilder().Build(message, CorrelationId).Build();
|
||||
AssertPictureSourceSlip(slip, RoutingSlipVariableNames.ProcessKinds.AlbumPicture, ActivityNames.PublishAlbumPictureProcessingEvent);
|
||||
}
|
||||
|
||||
AssertPictureSourceSlip(slip, RoutingSlipVariableNames.ProcessKinds.PlayListCreation, ActivityNames.PublishPlayListPictureProcessingEvent);
|
||||
}
|
||||
[Fact]
|
||||
public void PictureSource_CreatePlayList_CopiesConsumesAndPublishesInOrder()
|
||||
{
|
||||
var message = new CreatePlayListResourcesEvent(SubjectId, IntentId, "bucket", "source-key", "final-key", Sizes);
|
||||
|
||||
[Fact]
|
||||
public void PictureSource_UpdatePlayList_UsesThePlayListPictureProcessKind()
|
||||
{
|
||||
var message = new UpdatePlayListPictureSourceEvent(SubjectId, IntentId, "bucket", "source-key", "final-key", Sizes);
|
||||
var slip = new PictureSourceRoutingSlipBuilder().Build(message, CorrelationId).Build();
|
||||
|
||||
var slip = new PictureSourceRoutingSlipBuilder().Build(message, CorrelationId).Build();
|
||||
AssertPictureSourceSlip(slip, RoutingSlipVariableNames.ProcessKinds.PlayListCreation, ActivityNames.PublishPlayListPictureProcessingEvent);
|
||||
}
|
||||
|
||||
AssertPictureSourceSlip(slip, RoutingSlipVariableNames.ProcessKinds.PlayListPicture, ActivityNames.PublishPlayListPictureProcessingEvent);
|
||||
}
|
||||
[Fact]
|
||||
public void PictureSource_UpdatePlayList_UsesThePlayListPictureProcessKind()
|
||||
{
|
||||
var message = new UpdatePlayListPictureSourceEvent(SubjectId, IntentId, "bucket", "source-key", "final-key", Sizes);
|
||||
|
||||
[Fact]
|
||||
public void AudioWorkflow_ChainsDownloadTranscodeTransferAndUpdate()
|
||||
{
|
||||
var configuration = new WorkerConfiguration();
|
||||
var message = new UpdateTrackAudioEvent(SubjectId, "source-bucket", "source-key", "destination-bucket", "destination-folder");
|
||||
var slip = new PictureSourceRoutingSlipBuilder().Build(message, CorrelationId).Build();
|
||||
|
||||
var slip = new AudioWorkflowRoutingSlipBuilder(configuration).Build(message, CorrelationId).Build();
|
||||
AssertPictureSourceSlip(slip, RoutingSlipVariableNames.ProcessKinds.PlayListPicture, ActivityNames.PublishPlayListPictureProcessingEvent);
|
||||
}
|
||||
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.GenerateAudioWorkflowPaths,
|
||||
ActivityNames.DownloadFile,
|
||||
ActivityNames.TranscodeAudio,
|
||||
ActivityNames.TransferFiles,
|
||||
ActivityNames.UpdateTrackAudio,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
Assert.Equal(RoutingSlipVariableNames.ProcessKinds.TrackAudio, slip.Variables[RoutingSlipVariableNames.Workflow.ProcessKind]);
|
||||
Assert.Equal(SubjectId, slip.Variables[RoutingSlipVariableNames.Workflow.SubjectId]);
|
||||
Assert.All(slip.Itinerary, activity => Assert.EndsWith("_execute", activity.Address.ToString()));
|
||||
}
|
||||
[Fact]
|
||||
public void AudioWorkflow_ChainsDownloadTranscodeTransferAndUpdate()
|
||||
{
|
||||
var configuration = new WorkerConfiguration();
|
||||
var message = new UpdateTrackAudioEvent(SubjectId, "source-bucket", "source-key", "destination-bucket", "destination-folder");
|
||||
|
||||
private static void AssertPictureSourceSlip(RoutingSlip slip, string processKind, string publishStep)
|
||||
{
|
||||
Assert.Equal(
|
||||
[ActivityNames.CopyPictureToFinal, ActivityNames.ConsumeUploadIntents, publishStep],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
var slip = new AudioWorkflowRoutingSlipBuilder(configuration).Build(message, CorrelationId).Build();
|
||||
|
||||
Assert.Equal(processKind, slip.Variables[RoutingSlipVariableNames.Workflow.ProcessKind]);
|
||||
Assert.Equal(SubjectId, slip.Variables[RoutingSlipVariableNames.Workflow.SubjectId]);
|
||||
Assert.Equal("bucket", slip.Variables[RoutingSlipVariableNames.Workflow.Bucket]);
|
||||
Assert.Equal("final-key", slip.Variables[RoutingSlipVariableNames.Workflow.PictureKey]);
|
||||
Assert.Equal(CorrelationId, slip.Variables[RoutingSlipVariableNames.Workflow.CorrelationId]);
|
||||
Assert.Equal(
|
||||
[
|
||||
ActivityNames.GenerateAudioWorkflowPaths,
|
||||
ActivityNames.DownloadFile,
|
||||
ActivityNames.TranscodeAudio,
|
||||
ActivityNames.TransferFiles,
|
||||
ActivityNames.UpdateTrackAudio,
|
||||
],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
Assert.Equal(RoutingSlipVariableNames.ProcessKinds.TrackAudio, slip.Variables[RoutingSlipVariableNames.Workflow.ProcessKind]);
|
||||
Assert.Equal(SubjectId, slip.Variables[RoutingSlipVariableNames.Workflow.SubjectId]);
|
||||
Assert.All(slip.Itinerary, activity => Assert.EndsWith("_execute", activity.Address.ToString()));
|
||||
}
|
||||
|
||||
var copy = new Dictionary<string, object>(slip.Itinerary[0].Arguments, StringComparer.OrdinalIgnoreCase);
|
||||
Assert.Equal("source-key", copy["SourceKey"]?.ToString());
|
||||
Assert.Equal("final-key", copy["DestinationKey"]?.ToString());
|
||||
private static void AssertPictureSourceSlip(RoutingSlip slip, string processKind, string publishStep)
|
||||
{
|
||||
Assert.Equal(
|
||||
[ActivityNames.CopyPictureToFinal, ActivityNames.ConsumeUploadIntents, publishStep],
|
||||
slip.Itinerary.Select(activity => activity.Name));
|
||||
|
||||
Assert.Equal(processKind, slip.Variables[RoutingSlipVariableNames.Workflow.ProcessKind]);
|
||||
Assert.Equal(SubjectId, slip.Variables[RoutingSlipVariableNames.Workflow.SubjectId]);
|
||||
Assert.Equal("bucket", slip.Variables[RoutingSlipVariableNames.Workflow.Bucket]);
|
||||
Assert.Equal("final-key", slip.Variables[RoutingSlipVariableNames.Workflow.PictureKey]);
|
||||
Assert.Equal(CorrelationId, slip.Variables[RoutingSlipVariableNames.Workflow.CorrelationId]);
|
||||
|
||||
var copy = new Dictionary<string, object>(slip.Itinerary[0].Arguments, StringComparer.OrdinalIgnoreCase);
|
||||
Assert.Equal("source-key", copy["SourceKey"]?.ToString());
|
||||
Assert.Equal("final-key", copy["DestinationKey"]?.ToString());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+225
-224
@@ -14,247 +14,248 @@ using Musify.Infrastructure.MassTransit.RoutingSlip;
|
||||
using Musify.Infrastructure.Tests.TestSupport;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.MassTransit;
|
||||
|
||||
/// <summary>Runs the picture-update activities inside real routing slips on the MassTransit test harness.</summary>
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class UpdatePicturesActivityTests(InfrastructureTestFixture fixture)
|
||||
namespace Musify.Infrastructure.Tests.MassTransit
|
||||
{
|
||||
private const string SmallVariable = "Picture.Small";
|
||||
private const string MediumVariable = "Picture.Medium";
|
||||
private const string LargeVariable = "Picture.Large";
|
||||
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
[Fact]
|
||||
public async Task Album_Execute_StoresTheNamesAndPublishesTheEvent()
|
||||
/// <summary>Runs the picture-update activities inside real routing slips on the MassTransit test harness.</summary>
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class UpdatePicturesActivityTests(InfrastructureTestFixture fixture)
|
||||
{
|
||||
var album = await SeedAlbumAsync(EntityPictures.Pending("old-original.webp"));
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
private const string SmallVariable = "Picture.Small";
|
||||
private const string MediumVariable = "Picture.Medium";
|
||||
private const string LargeVariable = "Picture.Large";
|
||||
|
||||
var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, album.Id, "uploads/1/albums/new-original.webp");
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!;
|
||||
Assert.Equal("new-original.webp", stored.OriginalName);
|
||||
Assert.Equal("small.webp", stored.SmallName);
|
||||
Assert.Equal("medium.webp", stored.MediumName);
|
||||
Assert.Equal("large.webp", stored.LargeName);
|
||||
Assert.True(await harness.Published.Any<AlbumPictureProcessed>(published => published.Context.Message.AlbumId == album.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PlayList_Execute_StoresTheNamesAndPublishesTheEvent()
|
||||
{
|
||||
var playList = await SeedPlayListAsync(EntityPictures.Pending("old.webp"));
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = SlipFor(UpdatePlayListPictureActivity.ExecuteEndpointName, playList.Id, "uploads/1/playlists/new.webp");
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.PlayLists.AsNoTracking().SingleAsync(p => p.Id == playList.Id, Ct)).Pictures!;
|
||||
Assert.Equal("new.webp", stored.OriginalName);
|
||||
Assert.Equal("small.webp", stored.SmallName);
|
||||
Assert.True(await harness.Published.Any<PlayListPictureProcessed>(published => published.Context.Message.PlayListId == playList.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Track_Execute_MarksThePicturesAsCompleted()
|
||||
{
|
||||
var track = await SeedTrackAsync();
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = SlipFor(UpdateTrackPictureActivity.ExecuteEndpointName, track.Id, "uploads/1/tracks/new.webp");
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures;
|
||||
Assert.Equal(ProcessingStatus.Completed, stored.ProcessingStatus);
|
||||
Assert.Equal("large.webp", stored.LargeName);
|
||||
Assert.True(await harness.Published.Any<TrackPictureProcessed>(published => published.Context.Message.TrackId == track.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Execute_MissingEntity_FaultsTheSlip()
|
||||
{
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, Guid.NewGuid(), "uploads/1/albums/x.webp");
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Execute_MissingVariable_FaultsTheSlip()
|
||||
{
|
||||
var album = await SeedAlbumAsync(EntityPictures.Pending("old.webp"));
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = RoutingSlips.Create(null).AddStep(
|
||||
"Update",
|
||||
UpdateAlbumPictureActivity.ExecuteEndpointName,
|
||||
new UpdatePicturesArguments(album.Id, "key.webp", SmallVariable, MediumVariable, LargeVariable));
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.Equal("old.webp", (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!.OriginalName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Album_LaterStepFails_CompensationRestoresThePreviousNames()
|
||||
{
|
||||
var album = await SeedAlbumAsync(EntityPictures.Pending("old-original.webp"));
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, album.Id, "uploads/1/albums/new-original.webp");
|
||||
slip.AddStep("Fail", AlwaysFailsActivity.ExecuteEndpointName, new AlwaysFailsArguments());
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
|
||||
await WaitUntilAsync(async () =>
|
||||
[Fact]
|
||||
public async Task Album_Execute_StoresTheNamesAndPublishesTheEvent()
|
||||
{
|
||||
await using var poll = fixture.CreateDatabase();
|
||||
return (await poll.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!.OriginalName == "old-original.webp";
|
||||
});
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!;
|
||||
Assert.Equal("old-original.webp", stored.OriginalName);
|
||||
Assert.Null(stored.SmallName);
|
||||
Assert.Null(stored.MediumName);
|
||||
Assert.Null(stored.LargeName);
|
||||
}
|
||||
var album = await SeedAlbumAsync(EntityPictures.Pending("old-original.webp"));
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
[Fact]
|
||||
public async Task Track_LaterStepFails_CompensationMarksThePicturesAsFailed()
|
||||
{
|
||||
var track = await SeedTrackAsync();
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, album.Id, "uploads/1/albums/new-original.webp");
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
var slip = SlipFor(UpdateTrackPictureActivity.ExecuteEndpointName, track.Id, "uploads/1/tracks/new.webp");
|
||||
slip.AddStep("Fail", AlwaysFailsActivity.ExecuteEndpointName, new AlwaysFailsArguments());
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!;
|
||||
Assert.Equal("new-original.webp", stored.OriginalName);
|
||||
Assert.Equal("small.webp", stored.SmallName);
|
||||
Assert.Equal("medium.webp", stored.MediumName);
|
||||
Assert.Equal("large.webp", stored.LargeName);
|
||||
Assert.True(await harness.Published.Any<AlbumPictureProcessed>(published => published.Context.Message.AlbumId == album.Id, Ct));
|
||||
}
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
|
||||
await WaitUntilAsync(async () =>
|
||||
[Fact]
|
||||
public async Task PlayList_Execute_StoresTheNamesAndPublishesTheEvent()
|
||||
{
|
||||
await using var poll = fixture.CreateDatabase();
|
||||
return (await poll.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures.ProcessingStatus == ProcessingStatus.Failed;
|
||||
});
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures;
|
||||
Assert.Equal(ProcessingStatus.Failed, stored.ProcessingStatus);
|
||||
Assert.Equal("old.webp", stored.OriginalName);
|
||||
}
|
||||
var playList = await SeedPlayListAsync(EntityPictures.Pending("old.webp"));
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
private static async Task WaitUntilAsync(Func<Task<bool>> condition)
|
||||
{
|
||||
var deadline = DateTime.UtcNow.AddSeconds(10);
|
||||
while (!await condition() && DateTime.UtcNow < deadline)
|
||||
await Task.Delay(100, Ct);
|
||||
}
|
||||
var slip = SlipFor(UpdatePlayListPictureActivity.ExecuteEndpointName, playList.Id, "uploads/1/playlists/new.webp");
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
private static RoutingSlipBuilder SlipFor(string endpointName, Guid subjectId, string originalKey)
|
||||
{
|
||||
var builder = RoutingSlips.Create(null).AddStep(
|
||||
"Update", endpointName, new UpdatePicturesArguments(subjectId, originalKey, SmallVariable, MediumVariable, LargeVariable));
|
||||
builder.AddVariable(SmallVariable, "pictures/small.webp");
|
||||
builder.AddVariable(MediumVariable, "pictures/medium.webp");
|
||||
builder.AddVariable(LargeVariable, "pictures/large.webp");
|
||||
return builder;
|
||||
}
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.PlayLists.AsNoTracking().SingleAsync(p => p.Id == playList.Id, Ct)).Pictures!;
|
||||
Assert.Equal("new.webp", stored.OriginalName);
|
||||
Assert.Equal("small.webp", stored.SmallName);
|
||||
Assert.True(await harness.Published.Any<PlayListPictureProcessed>(published => published.Context.Message.PlayListId == playList.Id, Ct));
|
||||
}
|
||||
|
||||
private ServiceProvider CreateProvider() =>
|
||||
new ServiceCollection()
|
||||
.AddScoped<IDatabase>(_ => fixture.CreateDatabase())
|
||||
.AddMassTransitTestHarness(bus =>
|
||||
[Fact]
|
||||
public async Task Track_Execute_MarksThePicturesAsCompleted()
|
||||
{
|
||||
var track = await SeedTrackAsync();
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = SlipFor(UpdateTrackPictureActivity.ExecuteEndpointName, track.Id, "uploads/1/tracks/new.webp");
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures;
|
||||
Assert.Equal(ProcessingStatus.Completed, stored.ProcessingStatus);
|
||||
Assert.Equal("large.webp", stored.LargeName);
|
||||
Assert.True(await harness.Published.Any<TrackPictureProcessed>(published => published.Context.Message.TrackId == track.Id, Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Execute_MissingEntity_FaultsTheSlip()
|
||||
{
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, Guid.NewGuid(), "uploads/1/albums/x.webp");
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Execute_MissingVariable_FaultsTheSlip()
|
||||
{
|
||||
var album = await SeedAlbumAsync(EntityPictures.Pending("old.webp"));
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = RoutingSlips.Create(null).AddStep(
|
||||
"Update",
|
||||
UpdateAlbumPictureActivity.ExecuteEndpointName,
|
||||
new UpdatePicturesArguments(album.Id, "key.webp", SmallVariable, MediumVariable, LargeVariable));
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.Equal("old.webp", (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!.OriginalName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Album_LaterStepFails_CompensationRestoresThePreviousNames()
|
||||
{
|
||||
var album = await SeedAlbumAsync(EntityPictures.Pending("old-original.webp"));
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, album.Id, "uploads/1/albums/new-original.webp");
|
||||
slip.AddStep("Fail", AlwaysFailsActivity.ExecuteEndpointName, new AlwaysFailsArguments());
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
|
||||
await WaitUntilAsync(async () =>
|
||||
{
|
||||
bus.SetKebabCaseEndpointNameFormatter();
|
||||
bus.AddActivity<UpdateAlbumPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
|
||||
bus.AddActivity<UpdatePlayListPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
|
||||
bus.AddActivity<UpdateTrackPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
|
||||
bus.AddExecuteActivity<AlwaysFailsActivity, AlwaysFailsArguments>();
|
||||
})
|
||||
.BuildServiceProvider(true);
|
||||
await using var poll = fixture.CreateDatabase();
|
||||
return (await poll.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!.OriginalName == "old-original.webp";
|
||||
});
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!;
|
||||
Assert.Equal("old-original.webp", stored.OriginalName);
|
||||
Assert.Null(stored.SmallName);
|
||||
Assert.Null(stored.MediumName);
|
||||
Assert.Null(stored.LargeName);
|
||||
}
|
||||
|
||||
private static async Task<ITestHarness> StartAsync(ServiceProvider provider)
|
||||
{
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
return harness;
|
||||
}
|
||||
|
||||
private async Task<User> SeedUserAsync()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"pictures-{Guid.NewGuid():N}"[..30];
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return user;
|
||||
}
|
||||
|
||||
private async Task<Album> SeedAlbumAsync(EntityPictures pictures)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"album-{Guid.NewGuid():N}";
|
||||
var album = new Album { Title = title, NormalizedTitle = title.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
|
||||
await database.Albums.AddAsync(album, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return album;
|
||||
}
|
||||
|
||||
private async Task<PlayList> SeedPlayListAsync(EntityPictures pictures)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"pl-{Guid.NewGuid():N}"[..30];
|
||||
var playList = new PlayList { Name = name, NormalizedName = name.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
|
||||
await database.PlayLists.AddAsync(playList, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return playList;
|
||||
}
|
||||
|
||||
private async Task<Track> SeedTrackAsync()
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"track-{Guid.NewGuid():N}";
|
||||
var track = new Track
|
||||
[Fact]
|
||||
public async Task Track_LaterStepFails_CompensationMarksThePicturesAsFailed()
|
||||
{
|
||||
Title = title,
|
||||
NormalizedTitle = title.ToUpperInvariant(),
|
||||
DurationSeconds = 10,
|
||||
OwnerUserId = user.Id,
|
||||
Pictures = new TrackPictures { OriginalName = "old.webp" },
|
||||
Audio = new TrackAudio()
|
||||
};
|
||||
await database.Tracks.AddAsync(track, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return track;
|
||||
}
|
||||
var track = await SeedTrackAsync();
|
||||
await using var provider = CreateProvider();
|
||||
var harness = await StartAsync(provider);
|
||||
|
||||
public sealed record AlwaysFailsArguments;
|
||||
var slip = SlipFor(UpdateTrackPictureActivity.ExecuteEndpointName, track.Id, "uploads/1/tracks/new.webp");
|
||||
slip.AddStep("Fail", AlwaysFailsActivity.ExecuteEndpointName, new AlwaysFailsArguments());
|
||||
await harness.Bus.Execute(slip.Build(), Ct);
|
||||
|
||||
public sealed class AlwaysFailsActivity : IExecuteActivity<AlwaysFailsArguments>
|
||||
{
|
||||
public const string ExecuteEndpointName = "always-fails";
|
||||
Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
|
||||
await WaitUntilAsync(async () =>
|
||||
{
|
||||
await using var poll = fixture.CreateDatabase();
|
||||
return (await poll.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures.ProcessingStatus == ProcessingStatus.Failed;
|
||||
});
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
var stored = (await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures;
|
||||
Assert.Equal(ProcessingStatus.Failed, stored.ProcessingStatus);
|
||||
Assert.Equal("old.webp", stored.OriginalName);
|
||||
}
|
||||
|
||||
public Task<ExecutionResult> Execute(ExecuteContext<AlwaysFailsArguments> context) =>
|
||||
throw new InvalidOperationException("Forced failure");
|
||||
private static async Task WaitUntilAsync(Func<Task<bool>> condition)
|
||||
{
|
||||
var deadline = DateTime.UtcNow.AddSeconds(10);
|
||||
while (!await condition() && DateTime.UtcNow < deadline)
|
||||
await Task.Delay(100, Ct);
|
||||
}
|
||||
|
||||
private static RoutingSlipBuilder SlipFor(string endpointName, Guid subjectId, string originalKey)
|
||||
{
|
||||
var builder = RoutingSlips.Create(null).AddStep(
|
||||
"Update", endpointName, new UpdatePicturesArguments(subjectId, originalKey, SmallVariable, MediumVariable, LargeVariable));
|
||||
builder.AddVariable(SmallVariable, "pictures/small.webp");
|
||||
builder.AddVariable(MediumVariable, "pictures/medium.webp");
|
||||
builder.AddVariable(LargeVariable, "pictures/large.webp");
|
||||
return builder;
|
||||
}
|
||||
|
||||
private ServiceProvider CreateProvider() =>
|
||||
new ServiceCollection()
|
||||
.AddScoped<IDatabase>(_ => fixture.CreateDatabase())
|
||||
.AddMassTransitTestHarness(bus =>
|
||||
{
|
||||
bus.SetKebabCaseEndpointNameFormatter();
|
||||
bus.AddActivity<UpdateAlbumPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
|
||||
bus.AddActivity<UpdatePlayListPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
|
||||
bus.AddActivity<UpdateTrackPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
|
||||
bus.AddExecuteActivity<AlwaysFailsActivity, AlwaysFailsArguments>();
|
||||
})
|
||||
.BuildServiceProvider(true);
|
||||
|
||||
private static async Task<ITestHarness> StartAsync(ServiceProvider provider)
|
||||
{
|
||||
var harness = provider.GetRequiredService<ITestHarness>();
|
||||
await harness.Start();
|
||||
return harness;
|
||||
}
|
||||
|
||||
private async Task<User> SeedUserAsync()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"pictures-{Guid.NewGuid():N}"[..30];
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return user;
|
||||
}
|
||||
|
||||
private async Task<Album> SeedAlbumAsync(EntityPictures pictures)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"album-{Guid.NewGuid():N}";
|
||||
var album = new Album { Title = title, NormalizedTitle = title.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
|
||||
await database.Albums.AddAsync(album, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return album;
|
||||
}
|
||||
|
||||
private async Task<PlayList> SeedPlayListAsync(EntityPictures pictures)
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var name = $"pl-{Guid.NewGuid():N}"[..30];
|
||||
var playList = new PlayList { Name = name, NormalizedName = name.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
|
||||
await database.PlayLists.AddAsync(playList, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return playList;
|
||||
}
|
||||
|
||||
private async Task<Track> SeedTrackAsync()
|
||||
{
|
||||
var user = await SeedUserAsync();
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var title = $"track-{Guid.NewGuid():N}";
|
||||
var track = new Track
|
||||
{
|
||||
Title = title,
|
||||
NormalizedTitle = title.ToUpperInvariant(),
|
||||
DurationSeconds = 10,
|
||||
OwnerUserId = user.Id,
|
||||
Pictures = new TrackPictures { OriginalName = "old.webp" },
|
||||
Audio = new TrackAudio()
|
||||
};
|
||||
await database.Tracks.AddAsync(track, Ct);
|
||||
await database.SaveChangesAsync(Ct);
|
||||
return track;
|
||||
}
|
||||
|
||||
public sealed record AlwaysFailsArguments;
|
||||
|
||||
public sealed class AlwaysFailsActivity : IExecuteActivity<AlwaysFailsArguments>
|
||||
{
|
||||
public const string ExecuteEndpointName = "always-fails";
|
||||
|
||||
public Task<ExecutionResult> Execute(ExecuteContext<AlwaysFailsArguments> context) =>
|
||||
throw new InvalidOperationException("Forced failure");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+36
-35
@@ -3,51 +3,52 @@ using Musify.Domain.Entities;
|
||||
using Musify.Infrastructure.Tests.TestSupport;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Persistence;
|
||||
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class AuditableEntityInterceptorTests(InfrastructureTestFixture fixture)
|
||||
namespace Musify.Infrastructure.Tests.Persistence
|
||||
{
|
||||
[Fact]
|
||||
public async Task SavingChanges_NewEntity_SetsCreatedAtAndUpdatedAtToNow()
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class AuditableEntityInterceptorTests(InfrastructureTestFixture fixture)
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var before = DateTime.UtcNow;
|
||||
[Fact]
|
||||
public async Task SavingChanges_NewEntity_SetsCreatedAtAndUpdatedAtToNow()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var before = DateTime.UtcNow;
|
||||
|
||||
var name = "audit-user";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, TestContext.Current.CancellationToken);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
var name = "audit-user";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, TestContext.Current.CancellationToken);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
var after = DateTime.UtcNow;
|
||||
var after = DateTime.UtcNow;
|
||||
|
||||
Assert.InRange(user.CreatedAt, before, after);
|
||||
Assert.InRange(user.UpdatedAt, before, after);
|
||||
}
|
||||
Assert.InRange(user.CreatedAt, before, after);
|
||||
Assert.InRange(user.UpdatedAt, before, after);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task SavingChanges_ModifiedEntity_BumpsUpdatedAtButKeepsCreatedAt()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
[Fact]
|
||||
public async Task SavingChanges_ModifiedEntity_BumpsUpdatedAtButKeepsCreatedAt()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var name = "audit-user-2";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, TestContext.Current.CancellationToken);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
var originalCreatedAt = user.CreatedAt;
|
||||
var name = "audit-user-2";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, TestContext.Current.CancellationToken);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
var originalCreatedAt = user.CreatedAt;
|
||||
|
||||
await Task.Delay(TimeSpan.FromMilliseconds(50), TestContext.Current.CancellationToken);
|
||||
await Task.Delay(TimeSpan.FromMilliseconds(50), TestContext.Current.CancellationToken);
|
||||
|
||||
user.Name = "audit-user-2-renamed";
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
user.Name = "audit-user-2-renamed";
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Equal(originalCreatedAt, user.CreatedAt);
|
||||
Assert.True(user.UpdatedAt > originalCreatedAt,
|
||||
$"original-created-at={originalCreatedAt:O}, final-updated-at={user.UpdatedAt:O}");
|
||||
Assert.Equal(originalCreatedAt, user.CreatedAt);
|
||||
Assert.True(user.UpdatedAt > originalCreatedAt,
|
||||
$"original-created-at={originalCreatedAt:O}, final-updated-at={user.UpdatedAt:O}");
|
||||
|
||||
await using var reader = fixture.CreateDatabase();
|
||||
var stored = await reader.Users.SingleAsync(u => u.Id == user.Id, TestContext.Current.CancellationToken);
|
||||
Assert.True(stored.UpdatedAt > stored.CreatedAt,
|
||||
$"stored-created-at={stored.CreatedAt:O}, stored-updated-at={stored.UpdatedAt:O}");
|
||||
await using var reader = fixture.CreateDatabase();
|
||||
var stored = await reader.Users.SingleAsync(u => u.Id == user.Id, TestContext.Current.CancellationToken);
|
||||
Assert.True(stored.UpdatedAt > stored.CreatedAt,
|
||||
$"stored-created-at={stored.CreatedAt:O}, stored-updated-at={stored.UpdatedAt:O}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,104 +4,105 @@ using Musify.Domain.ValueObjects;
|
||||
using Musify.Infrastructure.Tests.TestSupport;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Persistence;
|
||||
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class DatabaseTests(InfrastructureTestFixture fixture)
|
||||
namespace Musify.Infrastructure.Tests.Persistence
|
||||
{
|
||||
[Fact]
|
||||
public async Task SaveChangesAsync_TrackWithOwnedTypes_RoundTripsThroughPostgres()
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class DatabaseTests(InfrastructureTestFixture fixture)
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var userName = "roundtrip-user";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = userName, NormalizedName = userName.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, TestContext.Current.CancellationToken);
|
||||
|
||||
var trackTitle = "Round Trip Track";
|
||||
var track = new Track
|
||||
[Fact]
|
||||
public async Task SaveChangesAsync_TrackWithOwnedTypes_RoundTripsThroughPostgres()
|
||||
{
|
||||
Title = trackTitle,
|
||||
NormalizedTitle = trackTitle.ToUpperInvariant(),
|
||||
DurationSeconds = 123.4,
|
||||
OwnerUserId = user.Id,
|
||||
Owner = user,
|
||||
Pictures = new TrackPictures { OriginalName = "cover.webp", ProcessingStatus = ProcessingStatus.Pending },
|
||||
Audio = new TrackAudio { OriginalName = "song.mp3", TranscodeStatus = ProcessingStatus.Pending }
|
||||
};
|
||||
await database.Tracks.AddAsync(track, TestContext.Current.CancellationToken);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
await using var reloaded = fixture.CreateDatabase();
|
||||
var stored = await reloaded.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, TestContext.Current.CancellationToken);
|
||||
var userName = "roundtrip-user";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = userName, NormalizedName = userName.ToUpperInvariant() };
|
||||
await database.Users.AddAsync(user, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Equal(trackTitle, stored.Title);
|
||||
Assert.Equal("cover.webp", stored.Pictures.OriginalName);
|
||||
Assert.Equal("song.mp3", stored.Audio.OriginalName);
|
||||
Assert.Equal(user.Id, stored.OwnerUserId);
|
||||
}
|
||||
var trackTitle = "Round Trip Track";
|
||||
var track = new Track
|
||||
{
|
||||
Title = trackTitle,
|
||||
NormalizedTitle = trackTitle.ToUpperInvariant(),
|
||||
DurationSeconds = 123.4,
|
||||
OwnerUserId = user.Id,
|
||||
Owner = user,
|
||||
Pictures = new TrackPictures { OriginalName = "cover.webp", ProcessingStatus = ProcessingStatus.Pending },
|
||||
Audio = new TrackAudio { OriginalName = "song.mp3", TranscodeStatus = ProcessingStatus.Pending }
|
||||
};
|
||||
await database.Tracks.AddAsync(track, TestContext.Current.CancellationToken);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
[Fact]
|
||||
public async Task SaveChangesAsync_TrackWithTags_RoundTripsThroughNativePostgresEnum()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
await using var reloaded = fixture.CreateDatabase();
|
||||
var stored = await reloaded.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, TestContext.Current.CancellationToken);
|
||||
|
||||
var userName = "tags-roundtrip-user";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = userName, NormalizedName = userName.ToUpperInvariant() };
|
||||
var track = BuildTrack(user, $"tags-{Guid.NewGuid():N}");
|
||||
track.Tags =
|
||||
[
|
||||
new TrackTag { TrackId = track.Id, Tag = Genre.Pop },
|
||||
new TrackTag { TrackId = track.Id, Tag = Genre.Rock }
|
||||
];
|
||||
Assert.Equal(trackTitle, stored.Title);
|
||||
Assert.Equal("cover.webp", stored.Pictures.OriginalName);
|
||||
Assert.Equal("song.mp3", stored.Audio.OriginalName);
|
||||
Assert.Equal(user.Id, stored.OwnerUserId);
|
||||
}
|
||||
|
||||
await database.AddRangeAsync(user, track);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
await using var reloaded = fixture.CreateDatabase();
|
||||
var stored = await reloaded.Tracks.AsNoTracking()
|
||||
.Include(t => t.Tags)
|
||||
.SingleAsync(t => t.Id == track.Id, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Equal([Genre.Pop, Genre.Rock], stored.Tags.Select(t => t.Tag).OrderBy(t => t));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AlbumHasTracks_DeletingAlbum_CascadesToTheLinkRows()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var userName = "cascade-user";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = userName, NormalizedName = userName.ToUpperInvariant() };
|
||||
var albumTitle = "Cascade Album";
|
||||
var album = new Album { Title = albumTitle, NormalizedTitle = albumTitle.ToUpperInvariant(), OwnerUserId = user.Id };
|
||||
var track = BuildTrack(user, $"cascade-{Guid.NewGuid():N}");
|
||||
var link = new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 };
|
||||
|
||||
await database.AddRangeAsync(user, album, track, link);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
await using var deleter = fixture.CreateDatabase();
|
||||
var albumToDelete = await deleter.Albums.SingleAsync(a => a.Id == album.Id, TestContext.Current.CancellationToken);
|
||||
deleter.Albums.Remove(albumToDelete);
|
||||
await deleter.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.AlbumHasTracks.AnyAsync(l => l.AlbumId == album.Id, TestContext.Current.CancellationToken));
|
||||
Assert.True(await verifier.Tracks.AnyAsync(t => t.Id == track.Id, TestContext.Current.CancellationToken));
|
||||
}
|
||||
|
||||
private static Track BuildTrack(User owner, string title)
|
||||
{
|
||||
return new Track
|
||||
[Fact]
|
||||
public async Task SaveChangesAsync_TrackWithTags_RoundTripsThroughNativePostgresEnum()
|
||||
{
|
||||
Title = title,
|
||||
NormalizedTitle = title.ToUpperInvariant(),
|
||||
DurationSeconds = 100,
|
||||
OwnerUserId = owner.Id,
|
||||
Owner = owner,
|
||||
Pictures = new TrackPictures(),
|
||||
Audio = new TrackAudio()
|
||||
};
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var userName = "tags-roundtrip-user";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = userName, NormalizedName = userName.ToUpperInvariant() };
|
||||
var track = BuildTrack(user, $"tags-{Guid.NewGuid():N}");
|
||||
track.Tags =
|
||||
[
|
||||
new TrackTag { TrackId = track.Id, Tag = Genre.Pop },
|
||||
new TrackTag { TrackId = track.Id, Tag = Genre.Rock }
|
||||
];
|
||||
|
||||
await database.AddRangeAsync(user, track);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
await using var reloaded = fixture.CreateDatabase();
|
||||
var stored = await reloaded.Tracks.AsNoTracking()
|
||||
.Include(t => t.Tags)
|
||||
.SingleAsync(t => t.Id == track.Id, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Equal([Genre.Pop, Genre.Rock], stored.Tags.Select(t => t.Tag).OrderBy(t => t));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AlbumHasTracks_DeletingAlbum_CascadesToTheLinkRows()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var userName = "cascade-user";
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = userName, NormalizedName = userName.ToUpperInvariant() };
|
||||
var albumTitle = "Cascade Album";
|
||||
var album = new Album { Title = albumTitle, NormalizedTitle = albumTitle.ToUpperInvariant(), OwnerUserId = user.Id };
|
||||
var track = BuildTrack(user, $"cascade-{Guid.NewGuid():N}");
|
||||
var link = new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 };
|
||||
|
||||
await database.AddRangeAsync(user, album, track, link);
|
||||
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
await using var deleter = fixture.CreateDatabase();
|
||||
var albumToDelete = await deleter.Albums.SingleAsync(a => a.Id == album.Id, TestContext.Current.CancellationToken);
|
||||
deleter.Albums.Remove(albumToDelete);
|
||||
await deleter.SaveChangesAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.AlbumHasTracks.AnyAsync(l => l.AlbumId == album.Id, TestContext.Current.CancellationToken));
|
||||
Assert.True(await verifier.Tracks.AnyAsync(t => t.Id == track.Id, TestContext.Current.CancellationToken));
|
||||
}
|
||||
|
||||
private static Track BuildTrack(User owner, string title)
|
||||
{
|
||||
return new Track
|
||||
{
|
||||
Title = title,
|
||||
NormalizedTitle = title.ToUpperInvariant(),
|
||||
DurationSeconds = 100,
|
||||
OwnerUserId = owner.Id,
|
||||
Owner = owner,
|
||||
Pictures = new TrackPictures(),
|
||||
Audio = new TrackAudio()
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,54 +4,55 @@ using SixLabors.ImageSharp;
|
||||
using SixLabors.ImageSharp.PixelFormats;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Services;
|
||||
|
||||
public sealed class PictureServiceTests
|
||||
namespace Musify.Infrastructure.Tests.Services
|
||||
{
|
||||
private static PictureService CreateService() => new(NullLogger<PictureService>.Instance);
|
||||
|
||||
private static MemoryStream CreateSourceImage(int width, int height)
|
||||
public sealed class PictureServiceTests
|
||||
{
|
||||
using var image = new Image<Rgba32>(width, height, new Rgba32(255, 0, 0));
|
||||
var stream = new MemoryStream();
|
||||
image.SaveAsPng(stream);
|
||||
stream.Position = 0;
|
||||
return stream;
|
||||
}
|
||||
private static PictureService CreateService() => new(NullLogger<PictureService>.Instance);
|
||||
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_LargerThanTarget_ShrinksToFitWithinTheRequestedBox()
|
||||
{
|
||||
using var source = CreateSourceImage(800, 600);
|
||||
private static MemoryStream CreateSourceImage(int width, int height)
|
||||
{
|
||||
using var image = new Image<Rgba32>(width, height, new Rgba32(255, 0, 0));
|
||||
var stream = new MemoryStream();
|
||||
image.SaveAsPng(stream);
|
||||
stream.Position = 0;
|
||||
return stream;
|
||||
}
|
||||
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 200, 200, TestContext.Current.CancellationToken);
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_LargerThanTarget_ShrinksToFitWithinTheRequestedBox()
|
||||
{
|
||||
using var source = CreateSourceImage(800, 600);
|
||||
|
||||
using var result = await Image.LoadAsync(resized, TestContext.Current.CancellationToken);
|
||||
Assert.InRange(result.Width, 1, 200);
|
||||
Assert.InRange(result.Height, 1, 200);
|
||||
Assert.True(result.Width == 200 || result.Height == 200, "expected the longer side to land exactly on the target box");
|
||||
}
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 200, 200, TestContext.Current.CancellationToken);
|
||||
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_ReturnsAValidWebpStream()
|
||||
{
|
||||
using var source = CreateSourceImage(100, 100);
|
||||
using var result = await Image.LoadAsync(resized, TestContext.Current.CancellationToken);
|
||||
Assert.InRange(result.Width, 1, 200);
|
||||
Assert.InRange(result.Height, 1, 200);
|
||||
Assert.True(result.Width == 200 || result.Height == 200, "expected the longer side to land exactly on the target box");
|
||||
}
|
||||
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 50, 50, TestContext.Current.CancellationToken);
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_ReturnsAValidWebpStream()
|
||||
{
|
||||
using var source = CreateSourceImage(100, 100);
|
||||
|
||||
var format = await Image.DetectFormatAsync(resized, TestContext.Current.CancellationToken);
|
||||
Assert.Equal("WEBP", format?.Name, ignoreCase: true);
|
||||
}
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 50, 50, TestContext.Current.CancellationToken);
|
||||
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_PreservesAspectRatio()
|
||||
{
|
||||
using var source = CreateSourceImage(400, 200);
|
||||
var format = await Image.DetectFormatAsync(resized, TestContext.Current.CancellationToken);
|
||||
Assert.Equal("WEBP", format?.Name, ignoreCase: true);
|
||||
}
|
||||
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 100, 100, TestContext.Current.CancellationToken);
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_PreservesAspectRatio()
|
||||
{
|
||||
using var source = CreateSourceImage(400, 200);
|
||||
|
||||
using var result = await Image.LoadAsync(resized, TestContext.Current.CancellationToken);
|
||||
Assert.Equal(100, result.Width);
|
||||
Assert.Equal(50, result.Height);
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 100, 100, TestContext.Current.CancellationToken);
|
||||
|
||||
using var result = await Image.LoadAsync(resized, TestContext.Current.CancellationToken);
|
||||
Assert.Equal(100, result.Width);
|
||||
Assert.Equal(50, result.Height);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,130 +7,131 @@ using Musify.Infrastructure.Services;
|
||||
using Musify.Infrastructure.Tests.TestSupport;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Services;
|
||||
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class StorageServiceTests(InfrastructureTestFixture fixture) : IAsyncLifetime
|
||||
namespace Musify.Infrastructure.Tests.Services
|
||||
{
|
||||
private StorageService service = null!;
|
||||
|
||||
public ValueTask InitializeAsync()
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class StorageServiceTests(InfrastructureTestFixture fixture) : IAsyncLifetime
|
||||
{
|
||||
var storageConfiguration = new InfrastructureStorageConfiguration
|
||||
private StorageService service = null!;
|
||||
|
||||
public ValueTask InitializeAsync()
|
||||
{
|
||||
Address = fixture.S3ServiceUrl,
|
||||
AccessKey = InfrastructureTestFixture.S3AccessKey,
|
||||
SecretAccessKey = InfrastructureTestFixture.S3SecretKey,
|
||||
ForcePathStyle = true,
|
||||
UseHttp = true,
|
||||
};
|
||||
service = new StorageService(fixture.CreateS3Client(), NullLogger<StorageService>.Instance, storageConfiguration);
|
||||
return ValueTask.CompletedTask;
|
||||
}
|
||||
var storageConfiguration = new InfrastructureStorageConfiguration
|
||||
{
|
||||
Address = fixture.S3ServiceUrl,
|
||||
AccessKey = InfrastructureTestFixture.S3AccessKey,
|
||||
SecretAccessKey = InfrastructureTestFixture.S3SecretKey,
|
||||
ForcePathStyle = true,
|
||||
UseHttp = true,
|
||||
};
|
||||
service = new StorageService(fixture.CreateS3Client(), NullLogger<StorageService>.Instance, storageConfiguration);
|
||||
return ValueTask.CompletedTask;
|
||||
}
|
||||
|
||||
public ValueTask DisposeAsync() => ValueTask.CompletedTask;
|
||||
public ValueTask DisposeAsync() => ValueTask.CompletedTask;
|
||||
|
||||
[Fact]
|
||||
public async Task UploadThenGetFile_RoundTripsTheSameBytes()
|
||||
{
|
||||
var key = $"tests/{Guid.NewGuid():N}/round-trip.txt";
|
||||
var content = "hello seaweedfs"u8.ToArray();
|
||||
|
||||
await service.UploadFileAsync(new MemoryStream(content), "text/plain", InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
await using var stream = await service.GetFileAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
Assert.NotNull(stream);
|
||||
using var reader = new StreamReader(stream, Encoding.UTF8);
|
||||
var readBack = await reader.ReadToEndAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Equal("hello seaweedfs", readBack);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetFileAsync_MissingObject_ReturnsNull()
|
||||
{
|
||||
var stream = await service.GetFileAsync(InfrastructureTestFixture.S3Bucket, $"tests/{Guid.NewGuid():N}/missing.txt", TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Null(stream);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task HeadObjectAsync_ExistingObject_ReturnsMetadata()
|
||||
{
|
||||
var key = $"tests/{Guid.NewGuid():N}/head.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("x"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.NotNull(metadata);
|
||||
Assert.Equal(1, metadata.ContentLength);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task HeadObjectAsync_MissingObject_ReturnsNull()
|
||||
{
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, $"tests/{Guid.NewGuid():N}/missing.txt", TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Null(metadata);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task RemoveFileAsync_ExistingObject_DeletesIt()
|
||||
{
|
||||
var key = $"tests/{Guid.NewGuid():N}/to-remove.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("x"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
await service.RemoveFileAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Null(await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CopyFileAsync_CopiesToTheDestinationKey()
|
||||
{
|
||||
var sourceKey = $"tests/{Guid.NewGuid():N}/source.txt";
|
||||
var destinationKey = $"tests/{Guid.NewGuid():N}/destination.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("copy-me"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, sourceKey, TestContext.Current.CancellationToken);
|
||||
|
||||
await service.CopyFileAsync(InfrastructureTestFixture.S3Bucket, sourceKey, InfrastructureTestFixture.S3Bucket, destinationKey, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.NotNull(await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, destinationKey, TestContext.Current.CancellationToken));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ListObjectsAsync_ReturnsEveryObjectUnderThePrefix()
|
||||
{
|
||||
var prefix = $"tests/{Guid.NewGuid():N}";
|
||||
await service.UploadFileAsync(new MemoryStream("a"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, $"{prefix}/a.txt", TestContext.Current.CancellationToken);
|
||||
await service.UploadFileAsync(new MemoryStream("b"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, $"{prefix}/b.txt", TestContext.Current.CancellationToken);
|
||||
|
||||
var keys = new List<string>();
|
||||
await foreach (var item in service.ListObjectsAsync(InfrastructureTestFixture.S3Bucket, prefix, TestContext.Current.CancellationToken))
|
||||
keys.Add(item.Key);
|
||||
|
||||
Assert.Equal([$"{prefix}/a.txt", $"{prefix}/b.txt"], keys.Order());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetUploadUrlAsync_PresignedPut_CanActuallyUploadTheObject()
|
||||
{
|
||||
var key = $"tests/{Guid.NewGuid():N}/presigned.txt";
|
||||
|
||||
var uploadUrl = await service.GetUploadUrlAsync(
|
||||
InfrastructureTestFixture.S3Bucket, key, "text/plain", TimeSpan.FromMinutes(5), cancellationToken: TestContext.Current.CancellationToken);
|
||||
|
||||
using var httpClient = new HttpClient();
|
||||
using var request = new HttpRequestMessage(HttpMethod.Put, uploadUrl)
|
||||
[Fact]
|
||||
public async Task UploadThenGetFile_RoundTripsTheSameBytes()
|
||||
{
|
||||
Content = new ByteArrayContent(Encoding.UTF8.GetBytes("presigned content"))
|
||||
};
|
||||
request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
|
||||
request.Headers.TryAddWithoutValidation("If-None-Match", "*");
|
||||
var response = await httpClient.SendAsync(request, TestContext.Current.CancellationToken);
|
||||
var key = $"tests/{Guid.NewGuid():N}/round-trip.txt";
|
||||
var content = "hello seaweedfs"u8.ToArray();
|
||||
|
||||
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
Assert.NotNull(metadata);
|
||||
Assert.Equal("presigned content".Length, metadata.ContentLength);
|
||||
await service.UploadFileAsync(new MemoryStream(content), "text/plain", InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
await using var stream = await service.GetFileAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
Assert.NotNull(stream);
|
||||
using var reader = new StreamReader(stream, Encoding.UTF8);
|
||||
var readBack = await reader.ReadToEndAsync(TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Equal("hello seaweedfs", readBack);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetFileAsync_MissingObject_ReturnsNull()
|
||||
{
|
||||
var stream = await service.GetFileAsync(InfrastructureTestFixture.S3Bucket, $"tests/{Guid.NewGuid():N}/missing.txt", TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Null(stream);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task HeadObjectAsync_ExistingObject_ReturnsMetadata()
|
||||
{
|
||||
var key = $"tests/{Guid.NewGuid():N}/head.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("x"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.NotNull(metadata);
|
||||
Assert.Equal(1, metadata.ContentLength);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task HeadObjectAsync_MissingObject_ReturnsNull()
|
||||
{
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, $"tests/{Guid.NewGuid():N}/missing.txt", TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Null(metadata);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task RemoveFileAsync_ExistingObject_DeletesIt()
|
||||
{
|
||||
var key = $"tests/{Guid.NewGuid():N}/to-remove.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("x"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
await service.RemoveFileAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Null(await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CopyFileAsync_CopiesToTheDestinationKey()
|
||||
{
|
||||
var sourceKey = $"tests/{Guid.NewGuid():N}/source.txt";
|
||||
var destinationKey = $"tests/{Guid.NewGuid():N}/destination.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("copy-me"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, sourceKey, TestContext.Current.CancellationToken);
|
||||
|
||||
await service.CopyFileAsync(InfrastructureTestFixture.S3Bucket, sourceKey, InfrastructureTestFixture.S3Bucket, destinationKey, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.NotNull(await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, destinationKey, TestContext.Current.CancellationToken));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ListObjectsAsync_ReturnsEveryObjectUnderThePrefix()
|
||||
{
|
||||
var prefix = $"tests/{Guid.NewGuid():N}";
|
||||
await service.UploadFileAsync(new MemoryStream("a"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, $"{prefix}/a.txt", TestContext.Current.CancellationToken);
|
||||
await service.UploadFileAsync(new MemoryStream("b"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, $"{prefix}/b.txt", TestContext.Current.CancellationToken);
|
||||
|
||||
var keys = new List<string>();
|
||||
await foreach (var item in service.ListObjectsAsync(InfrastructureTestFixture.S3Bucket, prefix, TestContext.Current.CancellationToken))
|
||||
keys.Add(item.Key);
|
||||
|
||||
Assert.Equal([$"{prefix}/a.txt", $"{prefix}/b.txt"], keys.Order());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetUploadUrlAsync_PresignedPut_CanActuallyUploadTheObject()
|
||||
{
|
||||
var key = $"tests/{Guid.NewGuid():N}/presigned.txt";
|
||||
|
||||
var uploadUrl = await service.GetUploadUrlAsync(
|
||||
InfrastructureTestFixture.S3Bucket, key, "text/plain", TimeSpan.FromMinutes(5), cancellationToken: TestContext.Current.CancellationToken);
|
||||
|
||||
using var httpClient = new HttpClient();
|
||||
using var request = new HttpRequestMessage(HttpMethod.Put, uploadUrl)
|
||||
{
|
||||
Content = new ByteArrayContent(Encoding.UTF8.GetBytes("presigned content"))
|
||||
};
|
||||
request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
|
||||
request.Headers.TryAddWithoutValidation("If-None-Match", "*");
|
||||
var response = await httpClient.SendAsync(request, TestContext.Current.CancellationToken);
|
||||
|
||||
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
|
||||
Assert.NotNull(metadata);
|
||||
Assert.Equal("presigned content".Length, metadata.ContentLength);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,104 +5,105 @@ using Musify.Infrastructure.Configuration;
|
||||
using Musify.Infrastructure.Services;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Services;
|
||||
|
||||
public sealed class StreamTicketServiceTests : IDisposable
|
||||
namespace Musify.Infrastructure.Tests.Services
|
||||
{
|
||||
private readonly string privateKeyPath = Path.GetTempFileName();
|
||||
private readonly RSA rsa = RSA.Create(2048);
|
||||
|
||||
public StreamTicketServiceTests() => File.WriteAllText(privateKeyPath, rsa.ExportPkcs8PrivateKeyPem());
|
||||
|
||||
public void Dispose()
|
||||
public sealed class StreamTicketServiceTests : IDisposable
|
||||
{
|
||||
rsa.Dispose();
|
||||
File.Delete(privateKeyPath);
|
||||
}
|
||||
private readonly string privateKeyPath = Path.GetTempFileName();
|
||||
private readonly RSA rsa = RSA.Create(2048);
|
||||
|
||||
private StreamTicketService CreateService(int ticketTtlSeconds = 3600) => new(new StreamTicketConfiguration
|
||||
{
|
||||
PrivateKeyPath = privateKeyPath,
|
||||
Audience = "media-gateway",
|
||||
Issuer = "musify-webapi",
|
||||
TicketTtlSeconds = ticketTtlSeconds
|
||||
});
|
||||
public StreamTicketServiceTests() => File.WriteAllText(privateKeyPath, rsa.ExportPkcs8PrivateKeyPem());
|
||||
|
||||
[Fact]
|
||||
public void IssueTicket_ReturnsATokenSignedWithTheConfiguredKeyAndClaims()
|
||||
{
|
||||
using var service = CreateService(ticketTtlSeconds: 120);
|
||||
|
||||
var ticket = service.IssueTicket(userId: 42, keyPrefix: "Tracks/ProcessedAudios/abc/");
|
||||
|
||||
Assert.Equal(120, ticket.ExpiresInSeconds);
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.Equal("42", jwt.GetClaim("sub").Value);
|
||||
Assert.Equal("Tracks/ProcessedAudios/abc/", jwt.GetClaim("prefix").Value);
|
||||
Assert.Equal("musify-webapi", jwt.Issuer);
|
||||
Assert.Contains("media-gateway", jwt.Audiences);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IssueTicket_AnonymousUser_OmitsTheSubClaim()
|
||||
{
|
||||
using var service = CreateService();
|
||||
|
||||
var ticket = service.IssueTicket(userId: null, keyPrefix: "Tracks/ProcessedAudios/abc/");
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.DoesNotContain(jwt.Claims, c => c.Type == "sub");
|
||||
Assert.Equal("Tracks/ProcessedAudios/abc/", jwt.GetClaim("prefix").Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IssueTicket_WithMaxBytes_IncludesTheMaxBytesClaim()
|
||||
{
|
||||
using var service = CreateService();
|
||||
|
||||
var ticket = service.IssueTicket(userId: null, keyPrefix: "Tracks/ProcessedAudios/abc/", maxBytes: 480_000);
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.Equal("480000", jwt.GetClaim("maxBytes").Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IssueTicket_WithoutMaxBytes_OmitsTheMaxBytesClaim()
|
||||
{
|
||||
using var service = CreateService();
|
||||
|
||||
var ticket = service.IssueTicket(userId: 1, keyPrefix: "Tracks/ProcessedAudios/abc/");
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.DoesNotContain(jwt.Claims, c => c.Type == "maxBytes");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task IssueTicket_TokenValidatesAgainstTheMatchingPublicKey()
|
||||
{
|
||||
using var service = CreateService();
|
||||
var ticket = service.IssueTicket(userId: 1, keyPrefix: "Tracks/ProcessedAudios/xyz/");
|
||||
|
||||
var publicKeyPem = rsa.ExportSubjectPublicKeyInfoPem();
|
||||
using var verifyingRsa = RSA.Create();
|
||||
verifyingRsa.ImportFromPem(publicKeyPem);
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var result = await handler.ValidateTokenAsync(ticket.Token, new TokenValidationParameters
|
||||
public void Dispose()
|
||||
{
|
||||
ValidIssuer = "musify-webapi",
|
||||
ValidAudience = "media-gateway",
|
||||
ValidateIssuer = true,
|
||||
ValidateAudience = true,
|
||||
ValidateLifetime = true,
|
||||
IssuerSigningKey = new RsaSecurityKey(verifyingRsa),
|
||||
rsa.Dispose();
|
||||
File.Delete(privateKeyPath);
|
||||
}
|
||||
|
||||
private StreamTicketService CreateService(int ticketTtlSeconds = 3600) => new(new StreamTicketConfiguration
|
||||
{
|
||||
PrivateKeyPath = privateKeyPath,
|
||||
Audience = "media-gateway",
|
||||
Issuer = "musify-webapi",
|
||||
TicketTtlSeconds = ticketTtlSeconds
|
||||
});
|
||||
|
||||
Assert.True(result.IsValid);
|
||||
[Fact]
|
||||
public void IssueTicket_ReturnsATokenSignedWithTheConfiguredKeyAndClaims()
|
||||
{
|
||||
using var service = CreateService(ticketTtlSeconds: 120);
|
||||
|
||||
var ticket = service.IssueTicket(userId: 42, keyPrefix: "Tracks/ProcessedAudios/abc/");
|
||||
|
||||
Assert.Equal(120, ticket.ExpiresInSeconds);
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.Equal("42", jwt.GetClaim("sub").Value);
|
||||
Assert.Equal("Tracks/ProcessedAudios/abc/", jwt.GetClaim("prefix").Value);
|
||||
Assert.Equal("musify-webapi", jwt.Issuer);
|
||||
Assert.Contains("media-gateway", jwt.Audiences);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IssueTicket_AnonymousUser_OmitsTheSubClaim()
|
||||
{
|
||||
using var service = CreateService();
|
||||
|
||||
var ticket = service.IssueTicket(userId: null, keyPrefix: "Tracks/ProcessedAudios/abc/");
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.DoesNotContain(jwt.Claims, c => c.Type == "sub");
|
||||
Assert.Equal("Tracks/ProcessedAudios/abc/", jwt.GetClaim("prefix").Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IssueTicket_WithMaxBytes_IncludesTheMaxBytesClaim()
|
||||
{
|
||||
using var service = CreateService();
|
||||
|
||||
var ticket = service.IssueTicket(userId: null, keyPrefix: "Tracks/ProcessedAudios/abc/", maxBytes: 480_000);
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.Equal("480000", jwt.GetClaim("maxBytes").Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IssueTicket_WithoutMaxBytes_OmitsTheMaxBytesClaim()
|
||||
{
|
||||
using var service = CreateService();
|
||||
|
||||
var ticket = service.IssueTicket(userId: 1, keyPrefix: "Tracks/ProcessedAudios/abc/");
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.DoesNotContain(jwt.Claims, c => c.Type == "maxBytes");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task IssueTicket_TokenValidatesAgainstTheMatchingPublicKey()
|
||||
{
|
||||
using var service = CreateService();
|
||||
var ticket = service.IssueTicket(userId: 1, keyPrefix: "Tracks/ProcessedAudios/xyz/");
|
||||
|
||||
var publicKeyPem = rsa.ExportSubjectPublicKeyInfoPem();
|
||||
using var verifyingRsa = RSA.Create();
|
||||
verifyingRsa.ImportFromPem(publicKeyPem);
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var result = await handler.ValidateTokenAsync(ticket.Token, new TokenValidationParameters
|
||||
{
|
||||
ValidIssuer = "musify-webapi",
|
||||
ValidAudience = "media-gateway",
|
||||
ValidateIssuer = true,
|
||||
ValidateAudience = true,
|
||||
ValidateLifetime = true,
|
||||
IssuerSigningKey = new RsaSecurityKey(verifyingRsa),
|
||||
});
|
||||
|
||||
Assert.True(result.IsValid);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+77
-76
@@ -10,97 +10,98 @@ using Musify.Infrastructure.Persistence;
|
||||
using Testcontainers.PostgreSql;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.TestSupport;
|
||||
|
||||
public sealed class InfrastructureTestFixture : IAsyncLifetime
|
||||
namespace Musify.Infrastructure.Tests.TestSupport
|
||||
{
|
||||
public const string S3AccessKey = "musify-test";
|
||||
public const string S3SecretKey = "musify-test-secret";
|
||||
public const string S3Bucket = "musify-test-bucket";
|
||||
|
||||
private static readonly string[] S3Actions = ["Admin", "Read", "Write"];
|
||||
|
||||
private readonly PostgreSqlContainer postgres = new PostgreSqlBuilder("postgres:17-alpine")
|
||||
.WithDatabase("musify_test")
|
||||
.WithUsername("postgres")
|
||||
.WithPassword("postgres")
|
||||
.Build();
|
||||
|
||||
private readonly IContainer seaweedFs = new ContainerBuilder("chrislusf/seaweedfs:latest")
|
||||
.WithEntrypoint("/bin/sh", "-c")
|
||||
.WithCommand(BuildSeaweedFsStartupScript())
|
||||
.WithPortBinding(9333, assignRandomHostPort: true)
|
||||
.WithPortBinding(8333, assignRandomHostPort: true)
|
||||
.WithWaitStrategy(Wait.ForUnixContainer()
|
||||
.UntilHttpRequestIsSucceeded(request => request.ForPort(9333).ForPath("/cluster/healthz")))
|
||||
.Build();
|
||||
|
||||
public string ConnectionString => postgres.GetConnectionString();
|
||||
|
||||
public string S3ServiceUrl => $"http://{seaweedFs.Hostname}:{seaweedFs.GetMappedPublicPort(8333)}";
|
||||
|
||||
public async ValueTask InitializeAsync()
|
||||
public sealed class InfrastructureTestFixture : IAsyncLifetime
|
||||
{
|
||||
await Task.WhenAll(postgres.StartAsync(), seaweedFs.StartAsync());
|
||||
public const string S3AccessKey = "musify-test";
|
||||
public const string S3SecretKey = "musify-test-secret";
|
||||
public const string S3Bucket = "musify-test-bucket";
|
||||
|
||||
await using var database = new Database(new DatabaseConfiguration { ConnectionString = ConnectionString });
|
||||
await database.Database.MigrateAsync();
|
||||
private static readonly string[] S3Actions = ["Admin", "Read", "Write"];
|
||||
|
||||
using var s3 = CreateS3Client();
|
||||
await s3.PutBucketAsync(S3Bucket);
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
await postgres.DisposeAsync();
|
||||
await seaweedFs.DisposeAsync();
|
||||
}
|
||||
|
||||
public Database CreateDatabase()
|
||||
{
|
||||
var configuration = new ConfigurationBuilder()
|
||||
.AddInMemoryCollection([new("Database:ConnectionString", ConnectionString)])
|
||||
private readonly PostgreSqlContainer postgres = new PostgreSqlBuilder("postgres:17-alpine")
|
||||
.WithDatabase("musify_test")
|
||||
.WithUsername("postgres")
|
||||
.WithPassword("postgres")
|
||||
.Build();
|
||||
|
||||
var services = new ServiceCollection();
|
||||
services.AddDatabase(configuration);
|
||||
return services.BuildServiceProvider().GetRequiredService<Database>();
|
||||
}
|
||||
private readonly IContainer seaweedFs = new ContainerBuilder("chrislusf/seaweedfs:latest")
|
||||
.WithEntrypoint("/bin/sh", "-c")
|
||||
.WithCommand(BuildSeaweedFsStartupScript())
|
||||
.WithPortBinding(9333, assignRandomHostPort: true)
|
||||
.WithPortBinding(8333, assignRandomHostPort: true)
|
||||
.WithWaitStrategy(Wait.ForUnixContainer()
|
||||
.UntilHttpRequestIsSucceeded(request => request.ForPort(9333).ForPath("/cluster/healthz")))
|
||||
.Build();
|
||||
|
||||
public IAmazonS3 CreateS3Client() =>
|
||||
new AmazonS3Client(S3AccessKey, S3SecretKey, new AmazonS3Config
|
||||
{
|
||||
ServiceURL = S3ServiceUrl,
|
||||
ForcePathStyle = true,
|
||||
UseHttp = true,
|
||||
});
|
||||
public string ConnectionString => postgres.GetConnectionString();
|
||||
|
||||
private static string BuildSeaweedFsStartupScript()
|
||||
{
|
||||
var identity = JsonSerializer.Serialize(new
|
||||
public string S3ServiceUrl => $"http://{seaweedFs.Hostname}:{seaweedFs.GetMappedPublicPort(8333)}";
|
||||
|
||||
public async ValueTask InitializeAsync()
|
||||
{
|
||||
identities = new[]
|
||||
await Task.WhenAll(postgres.StartAsync(), seaweedFs.StartAsync());
|
||||
|
||||
await using var database = new Database(new DatabaseConfiguration { ConnectionString = ConnectionString });
|
||||
await database.Database.MigrateAsync();
|
||||
|
||||
using var s3 = CreateS3Client();
|
||||
await s3.PutBucketAsync(S3Bucket);
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
await postgres.DisposeAsync();
|
||||
await seaweedFs.DisposeAsync();
|
||||
}
|
||||
|
||||
public Database CreateDatabase()
|
||||
{
|
||||
var configuration = new ConfigurationBuilder()
|
||||
.AddInMemoryCollection([new("Database:ConnectionString", ConnectionString)])
|
||||
.Build();
|
||||
|
||||
var services = new ServiceCollection();
|
||||
services.AddDatabase(configuration);
|
||||
return services.BuildServiceProvider().GetRequiredService<Database>();
|
||||
}
|
||||
|
||||
public IAmazonS3 CreateS3Client() =>
|
||||
new AmazonS3Client(S3AccessKey, S3SecretKey, new AmazonS3Config
|
||||
{
|
||||
new
|
||||
{
|
||||
name = "musify-test",
|
||||
credentials = new[] { new { accessKey = S3AccessKey, secretKey = S3SecretKey } },
|
||||
actions = S3Actions
|
||||
}
|
||||
}
|
||||
});
|
||||
ServiceURL = S3ServiceUrl,
|
||||
ForcePathStyle = true,
|
||||
UseHttp = true,
|
||||
});
|
||||
|
||||
return $"""
|
||||
private static string BuildSeaweedFsStartupScript()
|
||||
{
|
||||
var identity = JsonSerializer.Serialize(new
|
||||
{
|
||||
identities = new[]
|
||||
{
|
||||
new
|
||||
{
|
||||
name = "musify-test",
|
||||
credentials = new[] { new { accessKey = S3AccessKey, secretKey = S3SecretKey } },
|
||||
actions = S3Actions
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return $"""
|
||||
cat > /tmp/s3.conf <<'JSON'
|
||||
{identity}
|
||||
JSON
|
||||
exec weed server -ip.bind=0.0.0.0 -dir=/data -master.volumeSizeLimitMB=1024 -volume.max=0 -filer -s3 -s3.config=/tmp/s3.conf
|
||||
""";
|
||||
}
|
||||
}
|
||||
|
||||
[CollectionDefinition(Name)]
|
||||
public sealed class InfrastructureCollection : ICollectionFixture<InfrastructureTestFixture>
|
||||
{
|
||||
public const string Name = "Infrastructure";
|
||||
}
|
||||
}
|
||||
|
||||
[CollectionDefinition(Name)]
|
||||
public sealed class InfrastructureCollection : ICollectionFixture<InfrastructureTestFixture>
|
||||
{
|
||||
public const string Name = "Infrastructure";
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user