Files
ersatztv/ErsatzTV.Tests/Infrastructure/MediaSourceRepositoryPathReplacementScopeTests.cs
T
timothyandClaude Opus 4.8 c617a01e83 feat(api): add Jellyfin/Emby media-source write API (#202 slice S3)
New JellyfinMediaSourcesController (/api/media-sources/jellyfin, J1-J9) and
EmbyMediaSourcesController (/api/media-sources/emby, E1-E9), wrapping the
existing Jellyfin/Emby MediatR commands per the #202 design doc §A.3/§A.4.

Secure connection contract (§C3/§B, finding 1): the connection GET returns
only { address, hasApiKey } — the API key never crosses the wire. The PUT
retains the existing key when the incoming key is blank, sets a new one when
non-blank, and 422s "API key is required" on a blank first connect.

Finding 7 (lock-release discipline): DisconnectJellyfinHandler and
DisconnectEmbyHandler now wrap their work in try/finally so a throw from any
awaited dependency (repo delete, search-index commit, secret store) still
releases the family lock instead of wedging every future disconnect at 409.

Findings 2c/8 (path-replacement cross-source guard): UpdateJellyfinPathReplacementsHandler
and UpdateEmbyPathReplacementsHandler now reject, before any write, an incoming
positive Id that isn't owned by the route's media source, a null item, or a
blank RemotePath/LocalPath — all 422 with no partial mutation. Defense-in-depth
repo fix: the Jellyfin/Emby path-replacement UPDATE SQL in MediaSourceRepository
now scopes by {Jellyfin,Emby}MediaSourceId (was previously unscoped by Id alone,
allowing a PUT to one source to silently overwrite another source's row). The
Plex path-replacement method (~line 397) is untouched — that's slice S2's file.

Library preferences (§C4a): the controller validates the incoming id set
against the source's known libraries (reject foreign ids, require full
coverage, no Id=0) before dispatch, then — for §C7 — LockLibrary + enqueues
the SynchronizeXLibraries/SynchronizeXLibraryByIdIfNeeded pair per enabled
library (compensating unlock if the enqueue throws), and returns the reloaded
list (ids are not stable across a disable).

404s on id-taking endpoints come from a controller pre-check (GetXMediaSourceById
is None), not a handler NotFoundError, since Either.Apply/ToEitherAsync join any
NotFoundError into a flat 422 (finding 9).

Tests: controller route/404/409/422 tests for both families; disconnect
fault-injection tests proving the lock releases even when a dependency throws;
path-replacement handler tests for cross-source-id/blank/null-item rejection
and correct add/update/delete merge; a repository-level test proving the SQL
fix stops a same-family cross-source path-replacement overwrite.

No new commands, no DB migration, no OpenAPI regen (gated until S1-S3 merge
per the design doc's build-slice plan).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-11 15:47:42 +02:00

113 lines
3.9 KiB
C#

using ErsatzTV.Core.Domain;
using ErsatzTV.Infrastructure.Data;
using ErsatzTV.Infrastructure.Data.Repositories;
using ErsatzTV.Tests.Support;
using Microsoft.Extensions.Logging.Abstractions;
using NUnit.Framework;
using Shouldly;
namespace ErsatzTV.Tests.Infrastructure;
// Design #202 findings 2c/8 — repo-level defense-in-depth: the UPDATE for path replacements must be
// scoped to the owning media source so a PUT against source A can never silently overwrite a row
// that belongs to source B, even if a caller bypasses the handler-level ownership guard.
[TestFixture]
public class MediaSourceRepositoryPathReplacementScopeTests
{
private InMemoryTvContext _db = null!;
private MediaSourceRepository _repository = null!;
[SetUp]
public async Task SetUp()
{
_db = await InMemoryTvContext.CreateAsync();
_repository = new MediaSourceRepository(_db.Factory, NullLogger<MediaSourceRepository>.Instance);
}
[TearDown]
public async Task TearDown() => await _db.DisposeAsync();
[Test]
public async Task UpdatePathReplacements_Should_Not_Update_A_Row_Owned_By_Another_Jellyfin_Source()
{
var sourceA = new JellyfinMediaSource
{
ServerName = "A",
OperatingSystem = "Linux",
Connections = [],
PathReplacements = [new JellyfinPathReplacement { JellyfinPath = "/a", LocalPath = "/a-local" }]
};
var sourceB = new JellyfinMediaSource
{
ServerName = "B",
OperatingSystem = "Linux",
Connections = [],
PathReplacements = [new JellyfinPathReplacement { JellyfinPath = "/b", LocalPath = "/b-local" }]
};
await using (TvContext context = _db.CreateContext())
{
context.MediaSources.AddRange(sourceA, sourceB);
await context.SaveChangesAsync();
}
int bRowId = sourceB.PathReplacements.Single().Id;
// attack: source A's PUT carries source B's row id as an "update"
var maliciousUpdate = new JellyfinPathReplacement
{
Id = bRowId,
JellyfinPath = "/hijacked",
LocalPath = "/hijacked-local"
};
await _repository.UpdatePathReplacements(sourceA.Id, [], [maliciousUpdate], []);
await using TvContext verifyContext = _db.CreateContext();
JellyfinPathReplacement bRowAfter = await verifyContext.JellyfinPathReplacements.FindAsync(bRowId);
bRowAfter.JellyfinPath.ShouldBe("/b");
bRowAfter.LocalPath.ShouldBe("/b-local");
}
[Test]
public async Task UpdatePathReplacements_Should_Not_Update_A_Row_Owned_By_Another_Emby_Source()
{
var sourceA = new EmbyMediaSource
{
ServerName = "A",
OperatingSystem = "Linux",
Connections = [],
PathReplacements = [new EmbyPathReplacement { EmbyPath = "/a", LocalPath = "/a-local" }]
};
var sourceB = new EmbyMediaSource
{
ServerName = "B",
OperatingSystem = "Linux",
Connections = [],
PathReplacements = [new EmbyPathReplacement { EmbyPath = "/b", LocalPath = "/b-local" }]
};
await using (TvContext context = _db.CreateContext())
{
context.MediaSources.AddRange(sourceA, sourceB);
await context.SaveChangesAsync();
}
int bRowId = sourceB.PathReplacements.Single().Id;
var maliciousUpdate = new EmbyPathReplacement
{
Id = bRowId,
EmbyPath = "/hijacked",
LocalPath = "/hijacked-local"
};
await _repository.UpdatePathReplacements(sourceA.Id, [], [maliciousUpdate], []);
await using TvContext verifyContext = _db.CreateContext();
EmbyPathReplacement bRowAfter = await verifyContext.EmbyPathReplacements.FindAsync(bRowId);
bRowAfter.EmbyPath.ShouldBe("/b");
bRowAfter.LocalPath.ShouldBe("/b-local");
}
}