Add project reference for TeleWave.Infrastructure: include TeleWave.Infrastructure.csproj in TeleWave.Application.Tests project to support additional testing capabilities.

This commit is contained in:
Leonid Pershin
2026-07-25 20:12:04 +03:00
parent ed240ef73c
commit 4611f90d11
18 changed files with 2027 additions and 0 deletions
@@ -0,0 +1,157 @@
using NSubstitute;
using TeleWave.Application.Admin.Roles;
using TeleWave.Application.Admin.Roles.CreateRole;
using TeleWave.Application.Admin.Roles.DeleteRole;
using TeleWave.Application.Admin.Roles.ListRoles;
using TeleWave.Application.Admin.Roles.UpdateRole;
using TeleWave.Application.Admin.Users;
using TeleWave.Application.Admin.Users.DeleteUser;
using TeleWave.Application.Admin.Users.ResetPassword;
using TeleWave.Application.Admin.Users.UnblockUser;
using TeleWave.Application.Auth;
using TeleWave.Application.Auth.ChangePassword;
using TeleWave.Application.Common.Interfaces;
using TeleWave.Application.Common.Models;
using Xunit;
namespace TeleWave.Application.Tests.Admin;
public class DelegatingHandlersTests
{
private readonly IRoleService _roles = Substitute.For<IRoleService>();
private readonly IIdentityService _identity = Substitute.For<IIdentityService>();
private readonly ICurrentUser _currentUser = Substitute.For<ICurrentUser>();
[Fact]
public async Task Roles_HandlersDelegateToService()
{
var id = Guid.NewGuid();
var dto = new RoleDto(id, "editor", false);
_roles.CreateRoleAsync("editor", Arg.Any<CancellationToken>()).Returns(Result.Success(dto));
_roles
.UpdateRoleAsync(id, "editor", Arg.Any<CancellationToken>())
.Returns(Result.Success(dto));
_roles.DeleteRoleAsync(id, Arg.Any<CancellationToken>()).Returns(Result.Success());
_roles.ListRolesAsync(Arg.Any<CancellationToken>()).Returns(new List<RoleDto> { dto });
Assert.True(
(
await new CreateRoleCommandHandler(_roles).Handle(
new CreateRoleCommand("editor"),
default
)
).IsSuccess
);
Assert.True(
(
await new UpdateRoleCommandHandler(_roles).Handle(
new UpdateRoleCommand(id, "editor"),
default
)
).IsSuccess
);
Assert.True(
(
await new DeleteRoleCommandHandler(_roles).Handle(
new DeleteRoleCommand(id),
default
)
).IsSuccess
);
Assert.Single(
await new ListRolesQueryHandler(_roles).Handle(new ListRolesQuery(), default)
);
}
[Fact]
public async Task UnblockUser_And_ResetPassword_Delegate()
{
var id = Guid.NewGuid();
_identity.UnblockUserAsync(id, Arg.Any<CancellationToken>()).Returns(Result.Success());
_identity
.ResetPasswordAsync(id, "Password1", Arg.Any<CancellationToken>())
.Returns(Result.Success());
Assert.True(
(
await new UnblockUserCommandHandler(_identity).Handle(
new UnblockUserCommand(id),
default
)
).IsSuccess
);
Assert.True(
(
await new ResetUserPasswordCommandHandler(_identity).Handle(
new ResetUserPasswordCommand(id, "Password1"),
default
)
).IsSuccess
);
await _identity
.Received(1)
.ResetPasswordAsync(id, "Password1", Arg.Any<CancellationToken>());
}
[Fact]
public async Task DeleteUser_CannotDeleteSelf()
{
var me = Guid.NewGuid();
_currentUser.UserId.Returns(me);
var result = await new DeleteUserCommandHandler(_identity, _currentUser).Handle(
new DeleteUserCommand(me),
default
);
Assert.Equal(UserErrors.CannotDeleteSelf, result.Error);
await _identity
.DidNotReceive()
.DeleteUserAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>());
}
[Fact]
public async Task DeleteUser_OtherUser_Delegates()
{
_currentUser.UserId.Returns(Guid.NewGuid());
var target = Guid.NewGuid();
_identity.DeleteUserAsync(target, Arg.Any<CancellationToken>()).Returns(Result.Success());
var result = await new DeleteUserCommandHandler(_identity, _currentUser).Handle(
new DeleteUserCommand(target),
default
);
Assert.True(result.IsSuccess);
}
[Fact]
public async Task ChangePassword_Unauthorized_WhenNoCurrentUser()
{
_currentUser.UserId.Returns((Guid?)null);
var result = await new ChangePasswordCommandHandler(_identity, _currentUser).Handle(
new ChangePasswordCommand("old", "New12345"),
default
);
Assert.Equal(AuthErrors.Unauthorized, result.Error);
}
[Fact]
public async Task ChangePassword_Delegates_WhenAuthenticated()
{
var me = Guid.NewGuid();
_currentUser.UserId.Returns(me);
_identity
.ChangePasswordAsync(me, "old", "New12345", Arg.Any<CancellationToken>())
.Returns(Result.Success());
var result = await new ChangePasswordCommandHandler(_identity, _currentUser).Handle(
new ChangePasswordCommand("old", "New12345"),
default
);
Assert.True(result.IsSuccess);
}
}
@@ -0,0 +1,139 @@
using Microsoft.EntityFrameworkCore;
using TeleWave.Application.Broadcast;
using TeleWave.Application.Broadcast.Bumpers;
using TeleWave.Application.Tests.Support;
using TeleWave.Domain.Broadcast;
using Xunit;
namespace TeleWave.Application.Tests.Broadcast;
public class BumperVariantHandlersTests
{
private static readonly DateTimeOffset T0 = new(2026, 1, 1, 0, 0, 0, TimeSpan.Zero);
[Fact]
public async Task AddVariant_AutoNames_WhenBlank()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var template = channel.BumperTemplates[0];
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var result = await new AddBumperTextVariantCommandHandler(db).Handle(
new AddBumperTextVariantCommand(channel.Id, template.Id, " "),
CancellationToken.None
);
Assert.True(result.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var verify = fixture.New();
var stored = await verify
.Channels.Include(c => c.BumperTemplates)
.ThenInclude(t => t.Variants)
.FirstAsync(c => c.Id == channel.Id);
var variants = stored.BumperTemplates[0].Variants;
Assert.Equal(2, variants.Count);
Assert.Contains(variants, v => v.Name == "Текст 2");
}
[Fact]
public async Task AddVariant_UnknownTemplate_ReturnsNotFound()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var result = await new AddBumperTextVariantCommandHandler(db).Handle(
new AddBumperTextVariantCommand(channel.Id, Guid.NewGuid(), "x"),
CancellationToken.None
);
Assert.Equal(ChannelErrors.BumperTemplateNotFound, result.Error);
}
[Fact]
public async Task UpdateVariant_ChangesFields()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var template = channel.BumperTemplates[0];
var variant = template.Variants[0];
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var result = await new UpdateBumperTextVariantCommandHandler(db).Handle(
new UpdateBumperTextVariantCommand(
channel.Id,
template.Id,
variant.Id,
"Custom",
BumperTextKind.Free,
"NOW",
"NEXT",
"line1",
"line2",
BumperTrigger.Both,
7
),
CancellationToken.None
);
Assert.True(result.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var verify = fixture.New();
var stored = await verify
.Channels.Include(c => c.BumperTemplates)
.ThenInclude(t => t.Variants)
.FirstAsync(c => c.Id == channel.Id);
var v = stored.BumperTemplates[0].Variants[0];
Assert.Equal("Custom", v.Name);
Assert.Equal(BumperTextKind.Free, v.Kind);
Assert.Equal(7, v.Weight);
Assert.Equal(BumperTrigger.Both, v.Trigger);
}
[Fact]
public async Task RemoveVariant_CannotRemoveLast_ButRemovesExtra()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var template = channel.BumperTemplates[0];
var only = template.Variants[0];
var extra = template.AddVariant("Text 2");
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new RemoveBumperTextVariantCommandHandler(db);
var okRemove = await handler.Handle(
new RemoveBumperTextVariantCommand(channel.Id, template.Id, extra.Id),
CancellationToken.None
);
Assert.True(okRemove.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var db2 = fixture.New();
var lastGuard = await new RemoveBumperTextVariantCommandHandler(db2).Handle(
new RemoveBumperTextVariantCommand(channel.Id, template.Id, only.Id),
CancellationToken.None
);
Assert.Equal(ChannelErrors.CannotRemoveLastBumperTextVariant, lastGuard.Error);
}
}
@@ -0,0 +1,324 @@
using Microsoft.EntityFrameworkCore;
using TeleWave.Application.Broadcast;
using TeleWave.Application.Broadcast.AddChannelAd;
using TeleWave.Application.Broadcast.AddChannelShow;
using TeleWave.Application.Broadcast.CreateChannel;
using TeleWave.Application.Broadcast.CreateOverride;
using TeleWave.Application.Broadcast.DeleteOverride;
using TeleWave.Application.Broadcast.RemoveChannelShow;
using TeleWave.Application.Broadcast.UpdateChannelSettings;
using TeleWave.Application.Broadcast.UpdateChannelShow;
using TeleWave.Application.Tests.Support;
using TeleWave.Domain.Broadcast;
using TeleWave.Domain.Library;
using TeleWave.Domain.Media;
using Xunit;
namespace TeleWave.Application.Tests.Broadcast;
public class ChannelHandlersTests
{
private static readonly DateTimeOffset T0 = new(2026, 1, 1, 0, 0, 0, TimeSpan.Zero);
[Fact]
public async Task CreateChannel_Succeeds_AndRejectsDuplicateSlug()
{
var fixture = new TestDb();
await using var db = fixture.New();
var ok = await new CreateChannelCommandHandler(db).Handle(
new CreateChannelCommand("News", "news"),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
var dup = await new CreateChannelCommandHandler(db).Handle(
new CreateChannelCommand("Other", "news"),
CancellationToken.None
);
Assert.False(dup.IsSuccess);
Assert.Equal(ChannelErrors.DuplicateSlug, dup.Error);
}
[Fact]
public async Task AddChannelShow_HappyPath_AndErrors()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var show = Show.Create("S", ShowKind.Series);
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
seed.Shows.Add(show);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new AddChannelShowCommandHandler(db);
// неизвестный канал
var noChannel = await handler.Handle(
new AddChannelShowCommand(Guid.NewGuid(), show.Id, 1, BlockMode.Count, 1),
CancellationToken.None
);
Assert.Equal(ChannelErrors.NotFound, noChannel.Error);
// неизвестное шоу
var noShow = await handler.Handle(
new AddChannelShowCommand(channel.Id, Guid.NewGuid(), 1, BlockMode.Count, 1),
CancellationToken.None
);
Assert.Equal(ChannelErrors.ShowNotFound, noShow.Error);
// ок
var ok = await handler.Handle(
new AddChannelShowCommand(channel.Id, show.Id, 2, BlockMode.Count, 3),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
// повторно — уже добавлено
await using var db2 = fixture.New();
var dup = await new AddChannelShowCommandHandler(db2).Handle(
new AddChannelShowCommand(channel.Id, show.Id, 1, BlockMode.Count, 1),
CancellationToken.None
);
Assert.Equal(ChannelErrors.ShowAlreadyAdded, dup.Error);
}
[Fact]
public async Task RemoveChannelShow_RemovesOrReportsNotFound()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var cs = channel.AddShow(Guid.NewGuid(), 1, BlockMode.Count, 1);
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new RemoveChannelShowCommandHandler(db);
var missing = await handler.Handle(
new RemoveChannelShowCommand(channel.Id, Guid.NewGuid()),
CancellationToken.None
);
Assert.Equal(ChannelErrors.ChannelShowNotFound, missing.Error);
var ok = await handler.Handle(
new RemoveChannelShowCommand(channel.Id, cs.Id),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
}
[Fact]
public async Task AddChannelAd_HappyPath_AndAssetNotFound()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var asset = MediaAsset.Register("clip.mp4", ".mp4", MediaSource.Upload);
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
seed.MediaAssets.Add(asset);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new AddChannelAdCommandHandler(db);
var noAsset = await handler.Handle(
new AddChannelAdCommand(channel.Id, Guid.NewGuid()),
CancellationToken.None
);
Assert.Equal(ChannelErrors.AssetNotFound, noAsset.Error);
var ok = await handler.Handle(
new AddChannelAdCommand(channel.Id, asset.Id),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
}
[Fact]
public async Task UpdateChannelSettings_UpdatesBumperChances()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var result = await new UpdateChannelSettingsCommandHandler(db).Handle(
new UpdateChannelSettingsCommand(
channel.Id,
"c",
true,
AdInsertion.BetweenBlocks,
1,
true,
new BumperSettingsInput(
BumperFont.Sans,
5,
BumperSelection.WeightedRandom,
0.5,
0.2
),
null
),
CancellationToken.None
);
Assert.True(result.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var verify = fixture.New();
var stored = await verify.Channels.FindAsync(channel.Id);
Assert.Equal(0.5, stored!.BumperShowChangeChance);
Assert.Equal(0.2, stored.BumperEpisodeChangeChance);
Assert.Equal(BumperSelection.WeightedRandom, stored.BumperSelection);
}
[Fact]
public async Task UpdateChannelShow_SetsPreferredHours()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var cs = channel.AddShow(Guid.NewGuid(), 1, BlockMode.Count, 1);
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var result = await new UpdateChannelShowCommandHandler(db).Handle(
new UpdateChannelShowCommand(
channel.Id,
cs.Id,
3,
BlockMode.Count,
2,
true,
4,
[new HourWindowInput(18, 23)]
),
CancellationToken.None
);
Assert.True(result.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var verify = fixture.New();
var stored = await verify
.Channels.Include(c => c.Shows)
.ThenInclude(s => s.PreferredHours)
.FirstAsync(c => c.Id == channel.Id);
var show = Assert.Single(stored.Shows);
Assert.Equal(4, show.PreferredWeightMultiplier);
Assert.Single(show.PreferredHours);
}
[Fact]
public async Task CreateOverride_OneTime_Weekly_AndValidation()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var show = Show.Create("S", ShowKind.Series);
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
seed.Shows.Add(show);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new CreateProgrammingOverrideCommandHandler(db);
OverrideShowInput[] shows = [new OverrideShowInput(show.Id, 1)];
// Разовое окно — ок.
var oneTime = await handler.Handle(
new CreateProgrammingOverrideCommand(
channel.Id,
OverrideMode.Exclusive,
OverrideRecurrence.OneTime,
T0,
T0.AddHours(2),
null,
null,
null,
shows
),
CancellationToken.None
);
Assert.True(oneTime.IsSuccess);
// Еженедельное — ок.
var weekly = await handler.Handle(
new CreateProgrammingOverrideCommand(
channel.Id,
OverrideMode.Boost,
OverrideRecurrence.Weekly,
null,
null,
6,
600,
720,
shows
),
CancellationToken.None
);
Assert.True(weekly.IsSuccess);
// Невалидное окно (end <= start).
var bad = await handler.Handle(
new CreateProgrammingOverrideCommand(
channel.Id,
OverrideMode.Exclusive,
OverrideRecurrence.OneTime,
T0.AddHours(2),
T0,
null,
null,
null,
shows
),
CancellationToken.None
);
Assert.Equal(ChannelErrors.InvalidOverrideWindow, bad.Error);
}
[Fact]
public async Task DeleteOverride_RemovesOrReportsNotFound()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var ovr = channel.AddOverride(OverrideMode.Exclusive, T0, T0.AddHours(1));
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new DeleteProgrammingOverrideCommandHandler(db);
var missing = await handler.Handle(
new DeleteProgrammingOverrideCommand(channel.Id, Guid.NewGuid()),
CancellationToken.None
);
Assert.Equal(ChannelErrors.OverrideNotFound, missing.Error);
var ok = await handler.Handle(
new DeleteProgrammingOverrideCommand(channel.Id, ovr.Id),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
}
}
@@ -0,0 +1,286 @@
using Microsoft.EntityFrameworkCore;
using NSubstitute;
using TeleWave.Application.Broadcast;
using TeleWave.Application.Broadcast.Bumpers;
using TeleWave.Application.Broadcast.GetChannel;
using TeleWave.Application.Broadcast.GetSchedule;
using TeleWave.Application.Broadcast.ListChannels;
using TeleWave.Application.Broadcast.RemoveChannelAd;
using TeleWave.Application.Common.Interfaces;
using TeleWave.Application.Library.DeleteShow;
using TeleWave.Application.Library.GetShow;
using TeleWave.Application.Media.GetMedia;
using TeleWave.Application.Tests.Support;
using TeleWave.Domain.Broadcast;
using TeleWave.Domain.Library;
using TeleWave.Domain.Media;
using Xunit;
namespace TeleWave.Application.Tests.Broadcast;
public class QueryHandlersTests
{
private static readonly DateTimeOffset T0 = new(2026, 1, 1, 0, 0, 0, TimeSpan.Zero);
[Fact]
public async Task GetChannel_ReturnsDto_WithBumperAndOverride()
{
var fixture = new TestDb();
var channel = Channel.Create("News", "news", T0);
var show = Show.Create("S", ShowKind.Series);
channel.AddShow(show.Id, 1, BlockMode.Count, 1);
channel.AddWeeklyOverride(OverrideMode.Exclusive, 6, 600, 720).AddShow(show.Id, 1);
await using (var seed = fixture.New())
{
seed.Shows.Add(show);
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var result = await new GetChannelQueryHandler(db).Handle(
new GetChannelQuery(channel.Id),
CancellationToken.None
);
Assert.True(result.IsSuccess);
Assert.Equal("News", result.Value.Name);
Assert.Single(result.Value.BumperTemplates);
Assert.Single(result.Value.Overrides);
Assert.Equal(OverrideRecurrence.Weekly, result.Value.Overrides[0].Recurrence);
}
[Fact]
public async Task GetChannel_UnknownId_ReturnsNotFound()
{
var fixture = new TestDb();
await using var db = fixture.New();
var result = await new GetChannelQueryHandler(db).Handle(
new GetChannelQuery(Guid.NewGuid()),
CancellationToken.None
);
Assert.False(result.IsSuccess);
}
[Fact]
public async Task ListChannels_ReturnsSummaries()
{
var fixture = new TestDb();
await using (var seed = fixture.New())
{
seed.Channels.Add(Channel.Create("A", "a", T0));
seed.Channels.Add(Channel.Create("B", "b", T0));
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var result = await new ListChannelsQueryHandler(db).Handle(
new ListChannelsQuery(),
CancellationToken.None
);
Assert.Equal(2, result.Count);
}
[Fact]
public async Task GetChannelSchedule_ReturnsEntriesWithBumperLabel()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var show = Show.Create("Show A", ShowKind.Series);
var variant = channel.BumperTemplates[0].Variants[0];
var asset = MediaAsset.Register("Show.A.S01E01.mkv", ".mkv", MediaSource.Upload);
var program = ScheduleEntry.Program(
channel.Id,
asset.Id,
T0,
T0.AddMinutes(20),
show.Id,
0
);
var bumper = ScheduleEntry.Bumper(
channel.Id,
Guid.NewGuid(),
T0.AddMinutes(20),
T0.AddMinutes(20).AddSeconds(8),
show.Id,
variant.Id
);
await using (var seed = fixture.New())
{
seed.Shows.Add(show);
seed.Channels.Add(channel);
seed.MediaAssets.Add(asset);
seed.ScheduleEntries.Add(program);
seed.ScheduleEntries.Add(bumper);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var result = await new GetChannelScheduleQueryHandler(db).Handle(
new GetChannelScheduleQuery(channel.Id, T0.AddMinutes(-5), T0.AddHours(1)),
CancellationToken.None
);
Assert.True(result.IsSuccess);
Assert.Equal(2, result.Value.Count);
var bumperDto = result.Value.Single(e => e.Kind == ScheduleEntryKind.Bumper);
Assert.NotNull(bumperDto.BumperName);
}
[Fact]
public async Task GetShow_ReturnsDtoOrNotFound()
{
var fixture = new TestDb();
var show = Show.Create("A", ShowKind.Series);
await using (var seed = fixture.New())
{
seed.Shows.Add(show);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var ok = await new GetShowQueryHandler(db).Handle(
new GetShowQuery(show.Id),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
var missing = await new GetShowQueryHandler(db).Handle(
new GetShowQuery(Guid.NewGuid()),
CancellationToken.None
);
Assert.False(missing.IsSuccess);
}
[Fact]
public async Task GetMedia_ReturnsDtoOrNotFound()
{
var fixture = new TestDb();
var asset = MediaAsset.Register("clip.mp4", ".mp4", MediaSource.Upload);
await using (var seed = fixture.New())
{
seed.MediaAssets.Add(asset);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var ok = await new GetMediaAssetQueryHandler(db).Handle(
new GetMediaAssetQuery(asset.Id),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
var missing = await new GetMediaAssetQueryHandler(db).Handle(
new GetMediaAssetQuery(Guid.NewGuid()),
CancellationToken.None
);
Assert.False(missing.IsSuccess);
}
[Fact]
public async Task DeleteShow_RemovesOrNotFound()
{
var fixture = new TestDb();
var show = Show.Create("A", ShowKind.Series);
await using (var seed = fixture.New())
{
seed.Shows.Add(show);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var missing = await new DeleteShowCommandHandler(db).Handle(
new DeleteShowCommand(Guid.NewGuid()),
CancellationToken.None
);
Assert.False(missing.IsSuccess);
var ok = await new DeleteShowCommandHandler(db).Handle(
new DeleteShowCommand(show.Id),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
}
[Fact]
public async Task RemoveChannelAd_RemovesOrNotFound()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
var ad = channel.AddAd(Guid.NewGuid());
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new RemoveChannelAdCommandHandler(db);
Assert.Equal(
ChannelErrors.AdNotFound,
(
await handler.Handle(
new RemoveChannelAdCommand(channel.Id, Guid.NewGuid()),
CancellationToken.None
)
).Error
);
Assert.True(
(
await handler.Handle(
new RemoveChannelAdCommand(channel.Id, ad.Id),
CancellationToken.None
)
).IsSuccess
);
}
[Fact]
public async Task AddAndRemoveBumperTemplate_WorkThroughStorage()
{
var fixture = new TestDb();
var channel = Channel.Create("c", "c", T0);
await using (var seed = fixture.New())
{
seed.Channels.Add(channel);
await seed.SaveChangesAsync(CancellationToken.None);
}
Guid templateId;
await using (var db = fixture.New())
{
var added = await new AddBumperTemplateCommandHandler(db).Handle(
new AddBumperTemplateCommand(channel.Id, ""),
CancellationToken.None
);
Assert.True(added.IsSuccess);
templateId = added.Value;
await db.SaveChangesAsync(CancellationToken.None);
}
var storage = Substitute.For<IBumperTemplateStorage>();
await using (var db = fixture.New())
{
var removed = await new RemoveBumperTemplateCommandHandler(db, storage).Handle(
new RemoveBumperTemplateCommand(channel.Id, templateId),
CancellationToken.None
);
Assert.True(removed.IsSuccess);
}
storage.Received(1).DeleteTemplate(templateId);
// дефолтный блок удалить нельзя
await using (var db = fixture.New())
{
var def = await db
.Channels.Include(c => c.BumperTemplates)
.FirstAsync(c => c.Id == channel.Id);
var result = await new RemoveBumperTemplateCommandHandler(db, storage).Handle(
new RemoveBumperTemplateCommand(channel.Id, def.BumperTemplates[0].Id),
CancellationToken.None
);
Assert.Equal(ChannelErrors.CannotRemoveDefaultBumperTemplate, result.Error);
}
}
}
@@ -0,0 +1,163 @@
using Microsoft.EntityFrameworkCore;
using TeleWave.Application.Library;
using TeleWave.Application.Library.AddEpisode;
using TeleWave.Application.Library.CreateShow;
using TeleWave.Application.Library.RemoveEpisode;
using TeleWave.Application.Library.RenameShow;
using TeleWave.Application.Library.SetShowOriginalName;
using TeleWave.Application.Tests.Support;
using TeleWave.Domain.Library;
using TeleWave.Domain.Media;
using Xunit;
namespace TeleWave.Application.Tests.Library;
public class ShowHandlersTests
{
[Fact]
public async Task CreateShow_PersistsShow()
{
var fixture = new TestDb();
await using var db = fixture.New();
var result = await new CreateShowCommandHandler(db).Handle(
new CreateShowCommand("Симпсоны", ShowKind.Series, "desc", "The Simpsons"),
CancellationToken.None
);
Assert.True(result.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var verify = fixture.New();
var stored = await verify.Shows.FindAsync(result.Value);
Assert.Equal("Симпсоны", stored!.Name);
Assert.Equal("The Simpsons", stored.OriginalName);
}
[Fact]
public async Task RenameShow_ChangesName_OrNotFound()
{
var fixture = new TestDb();
var show = Show.Create("Old", ShowKind.Series);
await using (var seed = fixture.New())
{
seed.Shows.Add(show);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var missing = await new RenameShowCommandHandler(db).Handle(
new RenameShowCommand(Guid.NewGuid(), "New"),
CancellationToken.None
);
Assert.Equal(ShowErrors.NotFound, missing.Error);
var ok = await new RenameShowCommandHandler(db).Handle(
new RenameShowCommand(show.Id, " New "),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var verify = fixture.New();
Assert.Equal("New", (await verify.Shows.FindAsync(show.Id))!.Name);
}
[Fact]
public async Task SetOriginalName_TrimsAndClears()
{
var fixture = new TestDb();
var show = Show.Create("A", ShowKind.Series);
await using (var seed = fixture.New())
{
seed.Shows.Add(show);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var ok = await new SetShowOriginalNameCommandHandler(db).Handle(
new SetShowOriginalNameCommand(show.Id, " Orig "),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var verify = fixture.New();
Assert.Equal("Orig", (await verify.Shows.FindAsync(show.Id))!.OriginalName);
}
[Fact]
public async Task AddEpisode_ParsesNumbers_AndGuardsSingle()
{
var fixture = new TestDb();
var series = Show.Create("Series", ShowKind.Series);
var single = Show.Create("Movie", ShowKind.Single);
single.AddEpisode(Guid.NewGuid()); // уже занята единственная серия
var asset = MediaAsset.Register("The.Show.S03E07.WEBDL.mkv", ".mkv", MediaSource.Upload);
await using (var seed = fixture.New())
{
seed.Shows.Add(series);
seed.Shows.Add(single);
seed.MediaAssets.Add(asset);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new AddEpisodeCommandHandler(db);
// неизвестный ассет
var noAsset = await handler.Handle(
new AddEpisodeCommand(series.Id, Guid.NewGuid()),
CancellationToken.None
);
Assert.Equal(ShowErrors.AssetNotFound, noAsset.Error);
// single уже имеет серию
var singleGuard = await handler.Handle(
new AddEpisodeCommand(single.Id, asset.Id),
CancellationToken.None
);
Assert.Equal(ShowErrors.SingleAlreadyHasEpisode, singleGuard.Error);
// ок + распознавание S03E07
var ok = await handler.Handle(
new AddEpisodeCommand(series.Id, asset.Id),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
await db.SaveChangesAsync(CancellationToken.None);
await using var verify = fixture.New();
var stored = await verify.Shows.Include(s => s.Episodes).FirstAsync(s => s.Id == series.Id);
var episode = Assert.Single(stored.Episodes);
Assert.Equal(3, episode.Season);
Assert.Equal(7, episode.Episode);
}
[Fact]
public async Task RemoveEpisode_RemovesOrReportsNotFound()
{
var fixture = new TestDb();
var show = Show.Create("Series", ShowKind.Series);
var ep = show.AddEpisode(Guid.NewGuid());
await using (var seed = fixture.New())
{
seed.Shows.Add(show);
await seed.SaveChangesAsync(CancellationToken.None);
}
await using var db = fixture.New();
var handler = new RemoveEpisodeCommandHandler(db);
var missing = await handler.Handle(
new RemoveEpisodeCommand(show.Id, Guid.NewGuid()),
CancellationToken.None
);
Assert.Equal(ShowErrors.EpisodeNotFound, missing.Error);
var ok = await handler.Handle(
new RemoveEpisodeCommand(show.Id, ep.Id),
CancellationToken.None
);
Assert.True(ok.IsSuccess);
}
}
@@ -0,0 +1,17 @@
using Microsoft.EntityFrameworkCore;
using TeleWave.Infrastructure.Persistence;
namespace TeleWave.Application.Tests.Support;
/// <summary>
/// Общий InMemory-стенд поверх реального <see cref="AppDbContext"/> (с настоящими EF-конфигурациями).
/// Каждый экземпляр — своя изолированная БД; <see cref="New"/> отдаёт новый контекст на ту же БД,
/// чтобы можно было перечитать сохранённое свежим контекстом.
/// </summary>
internal sealed class TestDb
{
private readonly string _name = $"tw-{Guid.NewGuid():N}";
public AppDbContext New() =>
new(new DbContextOptionsBuilder<AppDbContext>().UseInMemoryDatabase(_name).Options);
}
@@ -25,5 +25,6 @@
<ItemGroup>
<ProjectReference Include="..\..\src\TeleWave.Application\TeleWave.Application.csproj" />
<ProjectReference Include="..\..\src\TeleWave.Infrastructure\TeleWave.Infrastructure.csproj" />
</ItemGroup>
</Project>
@@ -0,0 +1,142 @@
using TeleWave.Application.Admin.Users.CreateUser;
using TeleWave.Application.Admin.Users.ResetPassword;
using TeleWave.Application.Broadcast;
using TeleWave.Application.Broadcast.Bumpers;
using TeleWave.Application.Broadcast.CreateOverride;
using TeleWave.Application.Broadcast.UpdateChannelSettings;
using TeleWave.Application.Broadcast.UpdateChannelShow;
using TeleWave.Domain.Broadcast;
using Xunit;
namespace TeleWave.Application.Tests.Validators;
public class ValidatorTests
{
[Fact]
public void UpdateChannelShow_RejectsBadWeightMultiplierAndWindows()
{
var v = new UpdateChannelShowCommandValidator();
var good = new UpdateChannelShowCommand(
Guid.NewGuid(),
Guid.NewGuid(),
5,
BlockMode.Count,
3,
true,
4,
[new HourWindowInput(18, 23)]
);
Assert.True(v.Validate(good).IsValid);
var badMultiplier = good with { PreferredWeightMultiplier = 0 };
Assert.False(v.Validate(badMultiplier).IsValid);
var badWindow = good with { PreferredHours = [new HourWindowInput(23, 20)] };
Assert.False(v.Validate(badWindow).IsValid);
var badWeight = good with { Weight = 0 };
Assert.False(v.Validate(badWeight).IsValid);
}
[Fact]
public void UpdateBumperTextVariant_ChecksLengthsAndWeight()
{
var v = new UpdateBumperTextVariantCommandValidator();
var good = new UpdateBumperTextVariantCommand(
Guid.NewGuid(),
Guid.NewGuid(),
Guid.NewGuid(),
"Name",
BumperTextKind.NowNext,
"NOW",
"NEXT",
"l1",
"l2",
BumperTrigger.Both,
3
);
Assert.True(v.Validate(good).IsValid);
Assert.False(v.Validate(good with { Name = "" }).IsValid);
Assert.False(v.Validate(good with { Weight = -1 }).IsValid);
Assert.False(v.Validate(good with { Line1 = new string('x', 121) }).IsValid);
}
[Fact]
public void UpdateChannelSettings_ChecksRanges()
{
var v = new UpdateChannelSettingsCommandValidator();
var bumper = new BumperSettingsInput(
BumperFont.Sans,
10,
BumperSelection.Rotation,
0.5,
0.5
);
var good = new UpdateChannelSettingsCommand(
Guid.NewGuid(),
"Name",
true,
AdInsertion.BetweenBlocks,
2,
true,
bumper,
null
);
Assert.True(v.Validate(good).IsValid);
Assert.False(v.Validate(good with { Name = "" }).IsValid);
Assert.False(v.Validate(good with { AdsPerBreak = 99 }).IsValid);
Assert.False(
v.Validate(good with { Bumper = bumper with { ShowChangeChance = 2 } }).IsValid
);
}
[Fact]
public void CreateOverride_RequiresShows_WithValidWeights()
{
var v = new CreateProgrammingOverrideCommandValidator();
var good = new CreateProgrammingOverrideCommand(
Guid.NewGuid(),
OverrideMode.Boost,
OverrideRecurrence.OneTime,
DateTimeOffset.UtcNow,
DateTimeOffset.UtcNow.AddHours(1),
null,
null,
null,
[new OverrideShowInput(Guid.NewGuid(), 3)]
);
Assert.True(v.Validate(good).IsValid);
Assert.False(v.Validate(good with { Shows = [] }).IsValid);
Assert.False(
v.Validate(good with { Shows = [new OverrideShowInput(Guid.NewGuid(), 0)] }).IsValid
);
}
[Fact]
public void ResetUserPassword_RequiresMinLength()
{
var v = new ResetUserPasswordCommandValidator();
Assert.True(v.Validate(new ResetUserPasswordCommand(Guid.NewGuid(), "Password1")).IsValid);
Assert.False(v.Validate(new ResetUserPasswordCommand(Guid.NewGuid(), "short")).IsValid);
Assert.False(v.Validate(new ResetUserPasswordCommand(Guid.Empty, "Password1")).IsValid);
}
[Fact]
public void CreateUser_ChecksNameAndPassword()
{
var v = new CreateUserCommandValidator();
Assert.True(v.Validate(new CreateUserCommand("bob", "Password1", Guid.NewGuid())).IsValid);
Assert.False(v.Validate(new CreateUserCommand("ab", "Password1", Guid.NewGuid())).IsValid);
Assert.False(v.Validate(new CreateUserCommand("bob", "short", Guid.NewGuid())).IsValid);
Assert.False(v.Validate(new CreateUserCommand("bob", "Password1", Guid.Empty)).IsValid);
}
}