using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Text.Json; using System.Text.Json.Nodes; using System.Threading; using System.Threading.Tasks; using Xunit; namespace Moonfin.LiveTv.Tests; /// /// Counts saves and behaves like each server's AtomicFile: writes go to a temp file that is moved /// over the target, and a read that can't use the main file falls back to the .bak and copies it /// over the main file (promotion). The last contents written are also kept in memory, so tests can /// check the store without opening a file a background save may be replacing. /// internal sealed class CountingStateFile : IStateFile { private readonly object _gate = new(); private readonly Dictionary _written = new(StringComparer.OrdinalIgnoreCase); private int _writes; public int Writes => Volatile.Read(ref _writes); /// The contents last written to a path, or null when nothing was written to it yet. public string? LastWritten(string path) { lock (_gate) { return _written.TryGetValue(path, out var contents) ? contents : null; } } public T? Read(string path, Func parse) where T : class { if (TryParse(path, parse, out var fromMain)) { return fromMain; } var backup = path + ".bak"; if (TryParse(backup, parse, out var fromBackup)) { File.Copy(backup, path, overwrite: true); return fromBackup; } return null; } /// Every write fails as storage that went away does. public bool FailWrites { get; set; } public void Write(string path, string contents) { if (FailWrites) { throw new IOException("storage unavailable"); } Interlocked.Increment(ref _writes); lock (_gate) { var tmp = path + ".tmp"; File.WriteAllText(tmp, contents); for (var attempt = 0; ; attempt++) { try { File.Move(tmp, path, overwrite: true); break; } // A test may be reading the file this moment. catch (Exception ex) when ((ex is IOException or UnauthorizedAccessException) && attempt < 100) { Thread.Sleep(5); } } _written[path] = contents; } } /// Reads a file without blocking a writer, retrying while one is replacing it. public static string ReadShared(string path) { for (var attempt = 0; ; attempt++) { try { using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete); using var reader = new StreamReader(stream); return reader.ReadToEnd(); } catch (Exception ex) when ((ex is IOException or UnauthorizedAccessException) && attempt < 100) { Thread.Sleep(5); } } } private static bool TryParse(string path, Func parse, out T? result) where T : class { result = null; if (!File.Exists(path)) { return false; } try { result = parse(ReadShared(path)); return result != null; } catch (JsonException) { return false; } } } public sealed class RecordingOwnershipTests : IDisposable { private static readonly DateTime Start = new(2026, 11, 14, 20, 0, 0, DateTimeKind.Utc); private static readonly TimeSpan Bound = TimeSpan.FromSeconds(5); private static readonly Guid Jordan = Guid.Parse("11111111-1111-1111-1111-111111111111"); private static readonly Guid Alex = Guid.Parse("22222222-2222-2222-2222-222222222222"); private static readonly Guid Sam = Guid.Parse("33333333-3333-3333-3333-333333333333"); private readonly string _dir = Path.Combine(Path.GetTempPath(), "moonfin-owners-" + Guid.NewGuid().ToString("N")); private readonly ManualTimeProvider _clock = new(Start.AddHours(-1)); private readonly FakeRecordingHost _host = new(); private readonly ListRecordingLog _log = new(); private readonly CountingStateFile _stateFile = new(); private bool _enabled = true; public RecordingOwnershipTests() { _host.Clock = () => _clock.UtcNow; _host.Users.Add(new ServerUser(Jordan, "Jordan", "jordan-tag", false)); _host.Users.Add(new ServerUser(Alex, "Alex", "alex-tag", false)); _host.Users.Add(new ServerUser(Sam, "Sam", null, false)); } public void Dispose() { try { if (Directory.Exists(_dir)) { Directory.Delete(_dir, true); } } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { // A background save from a stopped watcher; the temp folder is left. } } private string StorePath => Path.Combine(_dir, RecordingOwnershipService.StoreFileName); private string IncompleteStorePath => Path.Combine(_dir, "incomplete.json"); // A new instance is a new server process. private RecordingOwnershipService NewService() => new(_host, _log, _stateFile, () => _clock.UtcNow, StorePath, () => _enabled); // The store as last saved: from the state file's in-memory copy, so a poll never holds the // file open while a watcher's background save replaces it; from disk before the first save. private OwnershipStoreData ReadStore() => JsonSerializer.Deserialize(_stateFile.LastWritten(StorePath) ?? CountingStateFile.ReadShared(StorePath))!; private GuideProgram AddProgram(string id, DateTime start, string series = "Bonanza", int? season = 1, int? episode = 1) { var program = new GuideProgram { Id = id, ItemId = Guid.TryParse(id, out var itemId) ? itemId : Guid.NewGuid(), SeriesId = "SH001", SeriesName = series, Season = season, Episode = episode, StartDate = start, EndDate = start.AddMinutes(20), }; _host.Programs.Add(program); return program; } private ScheduledTimer TimerOf(string programId) => _host.Timers.Single(t => t.ProgramId == programId); private static IReadOnlyList TagsOf(LibraryItem item) => item.Tags.ToList(); private static async Task WaitFor(Func condition, string what) { var until = DateTime.UtcNow + Bound; while (!condition()) { if (DateTime.UtcNow > until) { throw new Xunit.Sdk.XunitException("Timed out waiting for " + what); } await Task.Delay(10); } } private static async Task Bounded(Task task, string what) { var finished = await Task.WhenAny(task, Task.Delay(Bound)); Assert.True(finished == task, what + " did not finish within " + Bound.TotalSeconds + " s (deadlock?)"); return await task; } private sealed class RunningWatcher : IAsyncDisposable { private readonly CancellationTokenSource _cts = new(); private readonly RecordingOwnershipWatcher _watcher; private readonly Task _run; public RecordingOwnershipWatcher Watcher => _watcher; public RunningWatcher(FakeRecordingHost host, RecordingOwnershipService service, TimeSpan? followUp, Func? followUpDelay = null) { _watcher = followUpDelay != null ? new RecordingOwnershipWatcher(host, service, NoRecordingLog.Instance, followUpDelay) : followUp is { } delay ? new RecordingOwnershipWatcher(host, service, NoRecordingLog.Instance, delay) : new RecordingOwnershipWatcher(host, service, NoRecordingLog.Instance); // Subscribes to the host's events before its first await. _run = _watcher.RunAsync(_cts.Token); } public async ValueTask DisposeAsync() { _cts.Cancel(); await Task.WhenAny(_run, Task.Delay(Bound)); _watcher.Dispose(); _cts.Dispose(); } } // Starts a watcher and waits until its first sync has listed the timers (and, while something // records, listed them again for its id map) and released the service's lock. private async Task StartWatcher( RecordingOwnershipService service, TimeSpan? followUp = null, int expectedReads = 1, Func? followUpDelay = null) { var before = _host.TimerReads; var watcher = new RunningWatcher(_host, service, followUp, followUpDelay); await WaitFor(() => _host.TimerReads >= before + expectedReads, "the watcher's first sync"); // The fake counts a listing as it starts, so the id map is only known once it is swapped in. if (expectedReads > 1) { await WaitFor(() => watcher.Watcher.ServiceIdListings >= 1, "the watcher's id listing"); } await Bounded(service.GetMineAsync(Jordan, CancellationToken.None), "a call after the first sync"); return watcher; } // Plan: T1 plugin list [Fact] public async Task RecordProgram_CreatesTimerAndOwnsIt() { AddProgram("p1", Start); var service = NewService(); var outcome = await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); Assert.NotNull(outcome); Assert.Equal("api-p1", outcome!.Id); Assert.False(outcome.Joined); Assert.Equal(new[] { new OwnerInfo(Jordan, "Jordan", "jordan-tag") }, outcome.Owners); Assert.Equal(new[] { "p1" }, _host.Scheduled); Assert.Single(_host.Timers); Assert.Equal(new[] { "api-p1" }, (await service.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); var saved = ReadStore(); Assert.Equal(1, saved.Version); Assert.Equal(new[] { Jordan }, saved.Timers["api-p1"]); Assert.Equal("t-p1", saved.TimerServiceIds["api-p1"]); Assert.Equal("livetv-recording-owners.json", RecordingOwnershipService.StoreFileName); } [Fact] public async Task RecordProgram_ExistingTimer_JoinsWithoutSecondTimer() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); var outcome = await service.RecordProgramAsync("p1", Alex, CancellationToken.None); Assert.NotNull(outcome); Assert.True(outcome!.Joined); Assert.Equal("api-p1", outcome.Id); Assert.Single(_host.Timers); Assert.Single(_host.Scheduled); Assert.Equal(new[] { Jordan, Alex }, outcome.Owners.Select(o => o.UserId)); } [Fact] public async Task RecordSeries_ExistingRule_JoinsAndIgnoresSettings() { AddProgram("p1", Start); var service = NewService(); var newOnly = new Dictionary { ["RecordNewOnly"] = JsonSerializer.SerializeToElement(true) }; var everything = new Dictionary { ["RecordNewOnly"] = JsonSerializer.SerializeToElement(false) }; var created = await service.RecordSeriesAsync("p1", Jordan, newOnly, CancellationToken.None); // The server makes the rule's timers. _host.Timers.Add(new ScheduledTimer { ApiId = "api-s1", TimerId = "t-s1", ProgramId = "p1", SeriesTimerId = created!.Id, StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }); var joined = await service.RecordSeriesAsync("p1", Alex, everything, CancellationToken.None); Assert.False(created.Joined); Assert.NotNull(joined); Assert.True(joined!.Joined); Assert.Equal(created.Id, joined.Id); Assert.Single(_host.SeriesRules); // Only the creating call's settings ever reached the server: RecordNewOnly stays true. var creation = Assert.Single(_host.SeriesCreations); Assert.True(creation.Overrides!["RecordNewOnly"].GetBoolean()); Assert.Equal(new[] { Jordan, Alex }, joined.Owners.Select(o => o.UserId)); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Timers["api-s1"]); } [Fact] public async Task Sync_TimerMovesBetweenRules_OwnersOnlyAdded() { AddProgram("p1", Start); _host.SeriesRules.Add(new SeriesRule("rule-a", null, "Bonanza")); _host.SeriesRules.Add(new SeriesRule("rule-b", null, "Bonanza")); var timer = new ScheduledTimer { ApiId = "api-1", TimerId = "t-1", ProgramId = "p1", SeriesTimerId = "rule-a", StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }; _host.Timers.Add(timer); // A rule can only be claimed by someone who can see what it records, so rule-b needs a timer. AddProgram("p2", Start.AddDays(1)); _host.Timers.Add(new ScheduledTimer { ApiId = "api-2", TimerId = "t-2", ProgramId = "p2", SeriesTimerId = "rule-b", StartDate = Start.AddDays(1), EndDate = Start.AddDays(1).AddMinutes(20), Status = "New" }); var service = NewService(); await service.ClaimAsync(OwnedKind.Series, "rule-a", Jordan, CancellationToken.None); await service.ClaimAsync(OwnedKind.Series, "rule-b", Alex, CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Timers["api-1"]); timer.SeriesTimerId = "rule-b"; await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Timers["api-1"]); timer.SeriesTimerId = "rule-a"; await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Timers["api-1"]); } [Fact] public async Task ItemAdded_MatchesRecordedPath_CopiesOwnersAndTags() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); _host.StartRecording(TimerOf("p1"), "/rec/a.ts", 1, 1); await service.SyncAsync(CancellationToken.None); Assert.Equal("/rec/a.ts", ReadStore().TimerPaths["api-p1"]); var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); Assert.Equal(new[] { "Recorded by Jordan", "Recorded by Alex" }, TagsOf(item)); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Items[item.Id]); Assert.Equal(new[] { item.Id }, (await service.GetMineAsync(Alex, CancellationToken.None)).ItemIds); } [Fact] public async Task ItemRemovedThenReAdded_WithinSevenDays_RestoresOwners() { var item = _host.AddItem("/rec/a.ts"); var service = NewService(); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Alex, CancellationToken.None); await service.OnItemRemovedAsync(item.Id, CancellationToken.None); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); _clock.Advance(TimeSpan.FromDays(6)); await service.SyncAsync(CancellationToken.None); await NewService().OnItemAddedAsync(item, CancellationToken.None); var restarted = NewService(); Assert.Equal(new[] { item.Id }, (await restarted.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Items[item.Id]); Assert.Empty(ReadStore().Removed); } [Fact] public async Task ItemRemoved_AfterSevenDays_Forgotten() { var item = _host.AddItem("/rec/a.ts"); var service = NewService(); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); await service.OnItemRemovedAsync(item.Id, CancellationToken.None); _clock.Advance(TimeSpan.FromDays(7) + TimeSpan.FromMinutes(1)); await service.SyncAsync(CancellationToken.None); Assert.Empty(ReadStore().Removed); await service.OnItemAddedAsync(item, CancellationToken.None); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); Assert.Empty(ReadStore().Items); } [Fact] public async Task ItemRemoved_AfterSevenDays_NoSync_NotRestored() { var item = _host.AddItem("/rec/a.ts"); var service = NewService(); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); _host.Items.Remove(item); await service.OnItemRemovedAsync(item.Id, CancellationToken.None); // The server was down past the retention: its startup scan re-adds the item before any sync. _clock.Advance(TimeSpan.FromDays(7) + TimeSpan.FromMinutes(1)); var back = new LibraryItem { Id = item.Id, Path = item.Path }; _host.Items.Add(back); var tagWrites = _host.TagWrites.Count; await service.OnItemAddedAsync(back, CancellationToken.None); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); var saved = ReadStore(); Assert.Empty(saved.Items); Assert.Empty(saved.Removed); Assert.Equal(tagWrites, _host.TagWrites.Count); Assert.Empty(back.Tags); } // Fix 2: a rerun recorded to a deleted recording's file has the same item id. // Jordan's recording of the episode at /rec/bonanza.ts, then deleted; returns the item. private async Task DeletedJordanRecording(RecordingOwnershipService service) { var old = _host.AddItem("/rec/bonanza.ts"); await service.ClaimAsync(OwnedKind.Item, old.Id.ToString(), Jordan, CancellationToken.None); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(old)); _host.Items.Remove(old); await service.OnItemRemovedAsync(old.Id, CancellationToken.None); Assert.True(ReadStore().Removed.ContainsKey(old.Id)); return old; } // The rerun's new library item: same path, so the same id, with fresh metadata. private LibraryItem Rerun(LibraryItem old) { var item = new LibraryItem { Id = old.Id, Path = old.Path }; _host.Items.Add(item); return item; } [Fact] public async Task ItemReAdded_ByRerunTimerOnSamePath_TakesTimerOwnersNotTombstone() { var service = NewService(); var old = await DeletedJordanRecording(service); _clock.Advance(TimeSpan.FromDays(2)); AddProgram("p1", _clock.UtcNow, episode: 5); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); _host.StartRecording(TimerOf("p1"), old.Path!, 1, 5); await service.SyncAsync(CancellationToken.None); Assert.Equal(old.Path, ReadStore().TimerPaths["api-p1"]); var item = Rerun(old); await service.OnItemAddedAsync(item, CancellationToken.None); var saved = ReadStore(); Assert.Equal(new[] { Alex }, saved.Items[item.Id]); Assert.Contains("Recorded by Alex", TagsOf(item)); Assert.DoesNotContain("Recorded by Jordan", TagsOf(item)); Assert.False(saved.Removed.ContainsKey(item.Id)); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); } [Fact] public async Task RerunAttachedBySync_DiscardsTombstone_LaterReAddRestoresNewOwnersOnly() { var service = NewService(); var old = await DeletedJordanRecording(service); AddProgram("p1", Start, episode: 5); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); var timer = TimerOf("p1"); _host.StartRecording(timer, old.Path!, 1, 5); // No ItemAdded: the sync finds the item by the file it captures. var item = Rerun(old); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.Equal(new[] { Alex }, saved.Items[item.Id]); Assert.Equal(new[] { "Recorded by Alex" }, TagsOf(item)); Assert.False(saved.Removed.ContainsKey(item.Id)); // The recording finishes and its timer is forgotten; then the item leaves and comes back. _host.StopRecording(timer); _host.Timers.Remove(timer); await service.SyncAsync(CancellationToken.None); Assert.Empty(ReadStore().Timers); _host.Items.Remove(item); await service.OnItemRemovedAsync(item.Id, CancellationToken.None); var back = Rerun(old); await service.OnItemAddedAsync(back, CancellationToken.None); Assert.Equal(new[] { Alex }, ReadStore().Items[back.Id]); Assert.Equal(new[] { "Recorded by Alex" }, TagsOf(back)); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); } [Fact] public async Task Rerun_FinishedTimerOfDeletedRecordingOnSamePath_DoesNotOwnIt() { // Jordan's recording finishes and is deleted before a sync forgets its timer. AddProgram("p0", _clock.UtcNow); var service = NewService(); await service.RecordProgramAsync("p0", Jordan, CancellationToken.None); var first = TimerOf("p0"); _host.StartRecording(first, "/rec/bonanza.ts", 1, 5); await service.SyncAsync(CancellationToken.None); var old = _host.AddItem("/rec/bonanza.ts"); await service.OnItemAddedAsync(old, CancellationToken.None); _host.StopRecording(first); // A restart in between, so the removal can't tell the timer recorded this item. service = NewService(); _host.Items.Remove(old); await service.OnItemRemovedAsync(old.Id, CancellationToken.None); await service.SyncAsync(CancellationToken.None); Assert.Equal(old.Path, ReadStore().TimerPaths["api-p0"]); // Alex records the rerun to the same file. AddProgram("p1", _clock.UtcNow, episode: 5); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); _host.StartRecording(TimerOf("p1"), old.Path!, 1, 5); var item = Rerun(old); await service.OnItemAddedAsync(item, CancellationToken.None); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.Equal(new[] { Alex }, saved.Items[item.Id]); Assert.Equal(new[] { "Recorded by Alex" }, TagsOf(item)); Assert.Empty(saved.Removed); Assert.False(saved.Timers.ContainsKey("api-p0")); } // The recording timer's owners replace the owners of the item it writes. // A timer nobody owns through Moonfin (an official client, say) recording to a path now. private ScheduledTimer UnownedTimerRecording(string path, string id = "x") { var program = AddProgram("p-" + id, _clock.UtcNow, episode: 5); var timer = new ScheduledTimer { ApiId = "api-" + id, TimerId = "t-" + id, ProgramId = program.Id, StartDate = _clock.UtcNow, EndDate = _clock.UtcNow.AddMinutes(20), Status = "New" }; _host.Timers.Add(timer); _host.StartRecording(timer, path, 1, 5); return timer; } // A timer a user owns through Moonfin, recording to a path now. private async Task OwnedTimerRecording(RecordingOwnershipService service, string programId, Guid owner, string path) { AddProgram(programId, _clock.UtcNow); await service.RecordProgramAsync(programId, owner, CancellationToken.None); var timer = TimerOf(programId); _host.StartRecording(timer, path, 1, 1); return timer; } // Jordan claims a recording, then the item leaves. private async Task ClaimedThenRemoved(RecordingOwnershipService service, string path) { var item = _host.AddItem(path); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); _host.Items.Remove(item); await service.OnItemRemovedAsync(item.Id, CancellationToken.None); return item; } [Fact] public async Task Rerun_ByUnownedTimer_OnTombstonedPath_EndsWithNoOwners() { var service = NewService(); var old = await DeletedJordanRecording(service); _clock.Advance(TimeSpan.FromDays(2)); UnownedTimerRecording(old.Path!); // The item comes back before a sync has seen the timer record, so it is restored its old owners. var item = Rerun(old); await service.OnItemAddedAsync(item, CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); // The sync that sees it recording puts that right. await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.False(saved.Items.ContainsKey(item.Id)); Assert.Empty(saved.Removed); Assert.Empty(TagsOf(item)); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); Assert.Equal(old.Path, saved.TimerPaths["api-x"]); } [Fact] public async Task Rerun_ByUnownedTimer_SyncFindsItemFirst_DropsTombstoneAndOwners() { var service = NewService(); var old = await DeletedJordanRecording(service); UnownedTimerRecording(old.Path!); var item = Rerun(old); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.Empty(saved.Items); Assert.Empty(saved.Removed); Assert.Empty(TagsOf(item)); } [Fact] public async Task Rerun_ByOwnedTimer_ItemAddedBeforePathNoted_SyncReplacesTheTombstonedOwners() { var service = NewService(); var old = await DeletedJordanRecording(service); await OwnedTimerRecording(service, "p1", Alex, old.Path!); var item = Rerun(old); await service.OnItemAddedAsync(item, CancellationToken.None); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Alex }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Alex" }, TagsOf(item)); Assert.Empty(ReadStore().Removed); } // The recording was deleted and its path recorded again while the feature was off, so the // removal was never heard: the new item has the same id and the owners are still in the store. [Fact] public async Task StaleItemOwners_SwitchWasOff_UnownedRerunClearsThem() { var service = NewService(); var item = _host.AddItem("/rec/bonanza.ts"); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); UnownedTimerRecording(item.Path!); await service.SyncAsync(CancellationToken.None); Assert.Empty(ReadStore().Items); Assert.Empty(TagsOf(item)); } [Fact] public async Task StaleItemOwners_SwitchWasOff_OwnedRerunReplacesNotMerges() { var service = NewService(); var item = _host.AddItem("/rec/bonanza.ts"); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); await OwnedTimerRecording(service, "p1", Alex, item.Path!); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Alex }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Alex" }, TagsOf(item)); } [Fact] public async Task MissingItem_OnSync_BecomesTombstone() { var service = NewService(); var item = _host.AddItem("/rec/a.ts"); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); await service.SyncAsync(CancellationToken.None); // The removal event is ignored while the feature is off; the first sync after it is // turned back on finds the item gone. _enabled = false; await service.SyncAsync(CancellationToken.None); _host.Items.Remove(item); await service.OnItemRemovedAsync(item.Id, CancellationToken.None); Assert.True(ReadStore().Items.ContainsKey(item.Id)); _enabled = true; _clock.Advance(TimeSpan.FromMinutes(5)); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.Empty(saved.Items); Assert.Equal(new[] { Jordan }, saved.Removed[item.Id].Owners); Assert.Equal(_clock.UtcNow, saved.Removed[item.Id].RemovedAt); // It comes back within the retention with its owners. var back = Rerun(item); await service.OnItemAddedAsync(back, CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[back.Id]); } [Fact] public async Task ReturnedFile_NoTimerRecordingIt_RestoresOwners() { var service = NewService(); var old = await ClaimedThenRemoved(service, "/rec/a.ts"); // The storage drops out, the scan removes the item, and the same file comes back a day later. _clock.Advance(TimeSpan.FromDays(1)); var back = Rerun(old); await service.OnItemAddedAsync(back, CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[back.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(back)); Assert.Empty(ReadStore().Removed); // Nothing is recording to the path, so syncs leave it be. await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[back.Id]); } [Fact] public async Task ReturnedFile_TimersUnavailable_StillRestoresOwners() { var service = NewService(); var first = await ClaimedThenRemoved(service, "/rec/a.ts"); var second = await ClaimedThenRemoved(service, "/rec/b.ts"); // The startup scan re-adds them before Live TV is ready. _host.TimersUnavailable = true; _clock.Advance(TimeSpan.FromHours(1)); var firstBack = Rerun(first); var secondBack = Rerun(second); await service.OnItemAddedAsync(firstBack, CancellationToken.None); await service.OnItemAddedAsync(secondBack, CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[firstBack.Id]); Assert.Equal(new[] { Jordan }, ReadStore().Items[secondBack.Id]); Assert.Empty(ReadStore().Removed); } [Fact] public async Task ManyReturnedFiles_ListNoTimers() { var service = NewService(); var removed = new List(); for (var i = 0; i < 20; i++) { removed.Add(await ClaimedThenRemoved(service, "/rec/r" + i + ".ts")); } _clock.Advance(TimeSpan.FromHours(1)); var reads = _host.TimerReads; foreach (var item in removed) { await service.OnItemAddedAsync(Rerun(item), CancellationToken.None); } Assert.Equal(reads, _host.TimerReads); Assert.Equal(20, ReadStore().Items.Count); } [Fact] public async Task CancelledMidway_ItemArrivesWithinAllowance_TakesOwners() { var service = NewService(); var timer = await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); await service.SyncAsync(CancellationToken.None); Assert.Equal("/rec/a.ts", ReadStore().TimerPaths["api-p1"]); // The cancel is raised while the recording runs; the item reaches the library later. await service.OnTimerCancelledAsync(timer.TimerId, "/rec/a.ts", CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Timers["api-p1"]); _clock.Advance(RecordingOwnershipService.PostRecordingAllowance - TimeSpan.FromMinutes(1)); var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); var saved = ReadStore(); Assert.Equal(new[] { Jordan }, saved.Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); Assert.Empty(saved.Timers); Assert.Empty(saved.TimerPaths); Assert.Empty(saved.TimerPathsUntil); } [Fact] public async Task CancelledMidway_ItemArrivesAfterAllowance_NoOwners() { var service = NewService(); var timer = await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); await service.SyncAsync(CancellationToken.None); await service.OnTimerCancelledAsync(timer.TimerId, "/rec/a.ts", CancellationToken.None); _clock.Advance(RecordingOwnershipService.PostRecordingAllowance + TimeSpan.FromMinutes(1)); var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.False(saved.Items.ContainsKey(item.Id)); Assert.Empty(TagsOf(item)); Assert.Empty(saved.Timers); Assert.Empty(saved.TimerPaths); } [Fact] public async Task CancelledUnownedTimer_ItemInLibrary_LosesItsOwners() { var service = NewService(); var item = _host.AddItem("/rec/a.ts"); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); var timer = UnownedTimerRecording(item.Path!); await service.OnTimerCancelledAsync(timer.TimerId, item.Path, CancellationToken.None); Assert.Empty(ReadStore().Items); Assert.Empty(TagsOf(item)); Assert.Empty(ReadStore().TimerPaths); } [Fact] public async Task JoinWhileRecording_ItemGainsOwner() { var service = NewService(); await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); var item = _host.AddItem("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan", "Recorded by Alex" }, TagsOf(item)); } [Fact] public async Task ClaimItemWhileRecording_AddsToTimer_SurvivesNextSync() { var service = NewService(); await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); var item = _host.AddItem("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); var owners = await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Alex, CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, owners!.Select(o => o.UserId)); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Timers["api-p1"]); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan", "Recorded by Alex" }, TagsOf(item)); } [Fact] public async Task ClaimItemWhileRecording_ByUnownedTimer_TimerBecomesTheClaimersAndSurvivesNextSync() { var service = NewService(); var item = _host.AddItem("/rec/a.ts"); UnownedTimerRecording(item.Path!); await service.SyncAsync(CancellationToken.None); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Sam, CancellationToken.None); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Sam }, ReadStore().Items[item.Id]); Assert.Equal(new[] { Sam }, ReadStore().Timers["api-x"]); } [Fact] public async Task ClaimAfterRecordingEnded_NotUndoneBySync() { var service = NewService(); var timer = await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); var item = _host.AddItem("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); _host.StopRecording(timer); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[item.Id]); Assert.Empty(ReadStore().TimerPaths); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Alex, CancellationToken.None); await service.SyncAsync(CancellationToken.None); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan", "Recorded by Alex" }, TagsOf(item)); } [Fact] public async Task FinishedTimer_ItemWithinAllowance_TakesOwnersOnce() { var service = NewService(); var timer = await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); await service.SyncAsync(CancellationToken.None); _host.StopRecording(timer); _host.Timers.Remove(timer); await service.SyncAsync(CancellationToken.None); Assert.True(ReadStore().TimerPathsUntil.ContainsKey("api-p1")); _clock.Advance(RecordingOwnershipService.PostRecordingAllowance - TimeSpan.FromMinutes(1)); var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); Assert.Empty(ReadStore().Timers); Assert.Empty(ReadStore().TimerPaths); } [Fact] public async Task FinishedTimer_ItemPastAllowance_NotClaimedAndTimerForgotten() { var service = NewService(); var timer = await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); await service.SyncAsync(CancellationToken.None); _host.StopRecording(timer); _host.Timers.Remove(timer); await service.SyncAsync(CancellationToken.None); _clock.Advance(RecordingOwnershipService.PostRecordingAllowance + TimeSpan.FromMinutes(1)); var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.False(saved.Items.ContainsKey(item.Id)); Assert.Empty(saved.Timers); Assert.Empty(saved.TimerPaths); Assert.Empty(saved.TimerPathsUntil); } [Fact] public async Task DeletedWhileRecording_TimerForgottenOnceItsNoteLapses() { var service = NewService(); var timer = await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); var item = _host.AddItem("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[item.Id]); // Deleted while still recording: the timer is kept, then finishes with no item. _host.Items.Remove(item); await service.OnItemRemovedAsync(item.Id, CancellationToken.None); Assert.True(ReadStore().Timers.ContainsKey("api-p1")); _host.StopRecording(timer); await service.SyncAsync(CancellationToken.None); Assert.True(ReadStore().Timers.ContainsKey("api-p1")); // The allowance runs from the end of the timer's window. _clock.Advance(TimeSpan.FromHours(3)); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.Empty(saved.Timers); Assert.Empty(saved.TimerPaths); Assert.Equal(new[] { Jordan }, saved.Removed[item.Id].Owners); } [Fact] public async Task UnownedTimerRecordingTheSamePath_SupersedesAStoppedOwnedTimersNote() { var service = NewService(); var timer = await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); var item = _host.AddItem("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); // The recording is deleted, its timer stops, and something else records the path again. _host.Items.Remove(item); await service.OnItemRemovedAsync(item.Id, CancellationToken.None); _host.StopRecording(timer); await service.SyncAsync(CancellationToken.None); Assert.True(ReadStore().TimerPathsUntil.ContainsKey("api-p1")); UnownedTimerRecording("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); var back = Rerun(item); await service.OnItemAddedAsync(back, CancellationToken.None); var saved = ReadStore(); Assert.Empty(saved.Items); Assert.Empty(saved.Removed); Assert.False(saved.Timers.ContainsKey("api-p1")); Assert.Empty(TagsOf(back)); } [Fact] public async Task OldStore_TimerPathsWithoutExpiry_Loads() { Directory.CreateDirectory(_dir); File.WriteAllText( StorePath, "{\"Version\":1,\"Timers\":{\"api-p1\":[\"" + Jordan + "\"]},\"TimerPaths\":{\"api-p1\":\"/rec/a.ts\"}}"); var service = NewService(); // The timer isn't listed, so the first sync gives its file one allowance from now. await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.Equal("/rec/a.ts", saved.TimerPaths["api-p1"]); Assert.Equal(_clock.UtcNow + RecordingOwnershipService.PostRecordingAllowance, saved.TimerPathsUntil["api-p1"]); Assert.Equal(new[] { Jordan }, saved.Timers["api-p1"]); var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[item.Id]); Assert.Empty(ReadStore().TimerPaths); } [Fact] public async Task OldStore_TimerPathsWithoutExpiry_LapsAfterOneAllowance() { Directory.CreateDirectory(_dir); File.WriteAllText( StorePath, "{\"Version\":1,\"Timers\":{\"api-p1\":[\"" + Jordan + "\"]},\"TimerPaths\":{\"api-p1\":\"/rec/a.ts\"}}"); var service = NewService(); await service.SyncAsync(CancellationToken.None); _clock.Advance(RecordingOwnershipService.PostRecordingAllowance + TimeSpan.FromMinutes(1)); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.Empty(saved.Timers); Assert.Empty(saved.TimerPaths); Assert.Empty(saved.TimerPathsUntil); } [Fact] public async Task StoreWithRecordingNotes_KeepsVersionAndWritesPaths() { var service = NewService(); await OwnedTimerRecording(service, "p1", Jordan, "/rec/a.ts"); UnownedTimerRecording("/rec/b.ts"); await service.SyncAsync(CancellationToken.None); var json = JsonNode.Parse(_stateFile.LastWritten(StorePath)!)!.AsObject(); Assert.Equal(1, json["Version"]!.GetValue()); Assert.Equal("/rec/a.ts", json["TimerPaths"]!["api-p1"]!.GetValue()); } // Compat fix I2: the store's Version is honoured. [Fact] public async Task FutureVersionStore_IsReadButNeverOverwritten() { Directory.CreateDirectory(_dir); var json = "{\"Version\":2,\"Timers\":{\"api-p1\":[\"" + Jordan + "\"]},\"NewThing\":1}"; File.WriteAllText(StorePath, json); var before = File.ReadAllBytes(StorePath); AddProgram("p1", Start); AddProgram("p2", Start.AddHours(1), episode: 2); _host.Timers.Add(new ScheduledTimer { ApiId = "api-p1", TimerId = "t-p1", ProgramId = "p1", StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }); var service = NewService(); // Read: Jordan's timer is known. Assert.Equal(new[] { "api-p1" }, (await service.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); // Changes work in memory but never reach the file. Assert.NotNull(await service.RecordProgramAsync("p2", Alex, CancellationToken.None)); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { "api-p2" }, (await service.GetMineAsync(Alex, CancellationToken.None)).TimerIds); Assert.Equal(0, _stateFile.Writes); Assert.Equal(before, File.ReadAllBytes(StorePath)); Assert.Contains(_log.Entries, e => e.Kind == LogKind.Warn && e.Message.Contains("newer than this plugin")); } [Fact] public async Task FutureVersionStore_UnparseableByThisVersion_NeitherPromotedNorRebuilt() { // The newer plugin changed a member's type, so this version can't parse its file; the // .bak is the v1 file the newer plugin's first save left, which this version could parse. Directory.CreateDirectory(_dir); File.WriteAllText(StorePath, "{\"Version\":2,\"Timers\":{\"api-p1\":{\"owners\":[\"" + Jordan + "\"]}}}"); File.WriteAllText(StorePath + ".bak", "{\"Version\":1,\"Timers\":{\"api-p1\":[\"" + Jordan + "\"]}}"); var main = File.ReadAllBytes(StorePath); var backup = File.ReadAllBytes(StorePath + ".bak"); var tagged = _host.AddItem("/rec/a.ts"); tagged.Tags = new[] { "Recorded by Jordan" }; AddProgram("p2", Start); var service = NewService(); // Owners are unavailable, not rebuilt from tags or taken from the .bak. Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); // Changes work in memory only, and write no tags. Assert.NotNull(await service.RecordProgramAsync("p2", Alex, CancellationToken.None)); await service.ClaimAsync(OwnedKind.Item, tagged.Id.ToString(), Alex, CancellationToken.None); await service.SyncAsync(CancellationToken.None); Assert.Equal(0, _stateFile.Writes); Assert.Empty(_host.TagWrites); Assert.Equal(main, File.ReadAllBytes(StorePath)); Assert.Equal(backup, File.ReadAllBytes(StorePath + ".bak")); Assert.Empty(Directory.GetFiles(_dir, "*.corrupt-*")); Assert.Contains(_log.Entries, e => e.Kind == LogKind.Warn && e.Message.Contains("can't read")); } [Fact] public async Task CorruptStore_GoodBackup_IsPromoted() { // The control for the test above: a v1 main file that is only damaged still recovers from the .bak. Directory.CreateDirectory(_dir); File.WriteAllText(StorePath, "{ \"Version\": 1, \"Tim"); File.WriteAllText(StorePath + ".bak", "{\"Version\":1,\"Timers\":{\"api-p1\":[\"" + Jordan + "\"]}}"); var service = NewService(); Assert.Equal(new[] { "api-p1" }, (await service.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); Assert.Equal(File.ReadAllText(StorePath + ".bak"), File.ReadAllText(StorePath)); } [Fact] public async Task UnknownMembers_SurviveRoundTrip() { Directory.CreateDirectory(_dir); var gone = Guid.NewGuid(); var json = "{\"Version\":1,\"Timers\":{},\"NewThing\":{\"a\":[1,2]}," + "\"Removed\":{\"" + gone + "\":{\"Owners\":[\"" + Jordan + "\"],\"RemovedAt\":\"2026-11-14T18:00:00Z\",\"Reason\":\"nas\"}}}"; File.WriteAllText(StorePath, json); AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); Assert.True(_stateFile.Writes > 0); var saved = JsonNode.Parse(File.ReadAllText(StorePath))!; Assert.Equal(1, saved["Version"]!.GetValue()); Assert.Equal("[1,2]", saved["NewThing"]!["a"]!.ToJsonString()); Assert.Equal("nas", saved["Removed"]![gone.ToString()]!["Reason"]!.GetValue()); Assert.Equal(Alex.ToString(), saved["Timers"]!["api-p1"]![0]!.GetValue()); } // Compat fix M7: cancels of timers nobody owns don't list the timers each time. [Fact] public async Task CancelOfUnownedTimers_DoesNotListTimersPerEvent() { AddProgram("p1", Start); var service = NewService(); // Nothing owned: no listing at all. var reads = _host.TimerReads; for (var i = 1; i <= 5; i++) { await service.OnTimerCancelledAsync("t-gone" + i, CancellationToken.None); } Assert.Equal(reads, _host.TimerReads); // One owned timer, both ids known: a series rule deleted elsewhere cancels five timers nobody owns. await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); reads = _host.TimerReads; for (var i = 1; i <= 5; i++) { await service.OnTimerCancelledAsync("t-s" + i, CancellationToken.None); } Assert.Equal(reads, _host.TimerReads); Assert.Equal(new[] { Jordan }, ReadStore().Timers["api-p1"]); // The owned timer's own cancel, by its service id, still forgets its owners. _host.Timers.Clear(); await service.OnTimerCancelledAsync("t-p1", CancellationToken.None); Assert.Empty(ReadStore().Timers); } [Fact] public async Task CancelOfUnownedTimers_AfterRestartWithUnmappedOwnedTimer_ListsOnce() { // An owned timer whose two ids are one (Emby), so no service id is stored for it. AddProgram("p1", Start); _host.Timers.Add(new ScheduledTimer { ApiId = "e-1", TimerId = "e-1", ProgramId = "p1", StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }); await NewService().ClaimAsync(OwnedKind.Timer, "e-1", Jordan, CancellationToken.None); Assert.False(ReadStore().TimerServiceIds.ContainsKey("e-1")); // A restart forgets the id map; then a rule deletion cancels five timers nobody owns. _host.Timers.Clear(); var service = NewService(); var reads = _host.TimerReads; for (var i = 1; i <= 5; i++) { await service.OnTimerCancelledAsync("e-s" + i, CancellationToken.None); } Assert.Equal(reads + 1, _host.TimerReads); Assert.Equal(new[] { Jordan }, ReadStore().Timers["e-1"]); // The owned timer's own cancel still resolves without a listing. await service.OnTimerCancelledAsync("e-1", CancellationToken.None); Assert.Equal(reads + 1, _host.TimerReads); Assert.Empty(ReadStore().Timers); } [Fact] public async Task UserRenamed_RewritesTags() { var item = _host.AddItem("/rec/a.ts"); var service = NewService(); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); var renamed = new ServerUser(Jordan, "Grandpa", "jordan-tag", false); _host.Users[_host.Users.FindIndex(u => u.Id == Jordan)] = renamed; await service.OnUserUpdatedAsync(renamed, CancellationToken.None); Assert.Equal(new[] { "Recorded by Grandpa" }, TagsOf(item)); Assert.Equal(new[] { item.Id }, (await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); } [Fact] public async Task UserDeleted_RemovedFromOwnersAndTags() { AddProgram("p1", Start); _host.SeriesRules.Add(new SeriesRule("rule-a", null, "Bonanza")); var item = _host.AddItem("/rec/a.ts"); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); await service.ClaimAsync(OwnedKind.Series, "rule-a", Jordan, CancellationToken.None); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Alex, CancellationToken.None); _host.Users.RemoveAll(u => u.Id == Jordan); await service.OnUserDeletedAsync(Jordan, CancellationToken.None); var mine = await service.GetMineAsync(Jordan, CancellationToken.None); Assert.Empty(mine.TimerIds); Assert.Empty(mine.SeriesTimerIds); Assert.Empty(mine.ItemIds); var saved = ReadStore(); Assert.Equal(new[] { Alex }, saved.Timers["api-p1"]); Assert.False(saved.SeriesTimers.ContainsKey("rule-a")); Assert.Equal(new[] { Alex }, saved.Items[item.Id]); Assert.Equal(new[] { "Recorded by Alex" }, TagsOf(item)); } [Fact] public async Task CorruptStoreAndBackup_RebuildsItemsFromTags() { var tagged = _host.AddItem("/rec/a.ts"); tagged.Tags = new[] { "Recorded by Jordan", "Recorded by Nobody", "Favourite" }; var shared = _host.AddItem("/rec/b.ts"); shared.Tags = new[] { "recorded by alex", "Recorded by Sam" }; Directory.CreateDirectory(_dir); File.WriteAllText(StorePath, "{ not json"); File.WriteAllText(StorePath + ".bak", "also not json"); var service = NewService(); var lookup = await service.LookupAsync(Array.Empty(), Array.Empty(), new[] { tagged.Id, shared.Id }, Sam, CancellationToken.None); Assert.Equal(new[] { Jordan }, lookup.Items[tagged.Id].Select(o => o.UserId)); Assert.Equal(new[] { Alex, Sam }, lookup.Items[shared.Id].Select(o => o.UserId)); Assert.Contains(_log.Entries, e => e.Kind == LogKind.Warn && e.Message.Contains("no single user is named Nobody", StringComparison.Ordinal)); Assert.Equal(new[] { tagged.Id }, ReadStore().Items.Where(e => e.Value.Contains(Jordan)).Select(e => e.Key)); // The unusable files were set aside before the rebuilt store replaced them. Assert.Single(Directory.GetFiles(_dir, RecordingOwnershipService.StoreFileName + ".corrupt-*")); Assert.Single(Directory.GetFiles(_dir, RecordingOwnershipService.StoreFileName + ".bak.corrupt-*")); } [Fact] public async Task Lookup_HidesItemsCallerCannotSee_AndDisabledUsers() { var visible = _host.AddItem("/rec/a.ts"); var hidden = _host.AddItem("/rec/b.ts"); var shownProgram = AddProgram("p1", Start); var hiddenProgram = AddProgram("p2", Start.AddHours(1)); var controlProgram = AddProgram("p3", Start.AddHours(2)); var service = NewService(); foreach (var item in new[] { visible, hidden }) { await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Alex, CancellationToken.None); } await service.RecordProgramAsync(shownProgram.Id, Alex, CancellationToken.None); await service.RecordProgramAsync(hiddenProgram.Id, Jordan, CancellationToken.None); await service.RecordProgramAsync(controlProgram.Id, Jordan, CancellationToken.None); _host.HiddenItems.Add(hidden.Id); _host.HiddenPrograms.Add(hiddenProgram.ItemId.ToString("N")); _host.Users[_host.Users.FindIndex(u => u.Id == Alex)] = new ServerUser(Alex, "Alex", "alex-tag", IsDisabled: true); var lookup = await service.LookupAsync( new[] { "api-p1", "api-p2", "api-p3", "api-unknown" }, Array.Empty(), new[] { visible.Id, hidden.Id, Guid.NewGuid() }, Sam, CancellationToken.None); Assert.Equal(new[] { visible.Id }, lookup.Items.Keys); Assert.Equal(new[] { Jordan }, lookup.Items[visible.Id].Select(o => o.UserId)); // api-p1's only owner is disabled, so it has none to show; api-p2's program is hidden. // api-p3 is the control: an enabled owner's timer on a visible program. Assert.Equal(new[] { "api-p3" }, lookup.Timers.Keys); Assert.Equal(new[] { Jordan }, lookup.Timers["api-p3"].Select(o => o.UserId)); // Disabled owners stay owners; they are only left out of what clients are shown. Assert.Equal(new[] { Jordan, Alex }, ReadStore().Items[visible.Id]); } [Fact] public async Task Disabled_ReturnsEmptyAndIgnoresEvents() { AddProgram("p1", Start); _host.SeriesRules.Add(new SeriesRule("rule-a", null, "Bonanza")); var owned = _host.AddItem("/rec/a.ts"); var service = NewService(); await service.ClaimAsync(OwnedKind.Item, owned.Id.ToString(), Jordan, CancellationToken.None); var writes = _stateFile.Writes; var tagWrites = _host.TagWrites.Count; var reads = _host.TimerReads; _enabled = false; Assert.Null(await service.RecordProgramAsync("p1", Jordan, CancellationToken.None)); Assert.Null(await service.RecordSeriesAsync("p1", Jordan, null, CancellationToken.None)); Assert.Null(await service.ClaimAsync(OwnedKind.Series, "rule-a", Jordan, CancellationToken.None)); Assert.Null(await service.ClaimAsync(OwnedKind.Item, owned.Id.ToString(), Alex, CancellationToken.None)); var lookup = await service.LookupAsync(new[] { "api-p1" }, new[] { "rule-a" }, new[] { owned.Id }, Jordan, CancellationToken.None); Assert.Empty(lookup.Items); Assert.Empty(lookup.Timers); Assert.Empty(lookup.SeriesTimers); var mine = await service.GetMineAsync(Jordan, CancellationToken.None); Assert.Empty(mine.ItemIds); Assert.Empty(service.OwnersOfItems(new[] { owned.Id })); Assert.False(service.HasRecordingInProgress); await service.SyncAsync(CancellationToken.None); await service.OnItemRemovedAsync(owned.Id, CancellationToken.None); await service.OnItemAddedAsync(_host.AddItem("/rec/b.ts"), CancellationToken.None); await service.OnTimerCancelledAsync("t-p1", CancellationToken.None); await service.OnUserUpdatedAsync(new ServerUser(Jordan, "Grandpa", "jordan-tag", false), CancellationToken.None); await service.OnUserDeletedAsync(Jordan, CancellationToken.None); service.AddTimerOwners("api-p1", new[] { Jordan }); Assert.Empty(_host.Scheduled); Assert.Empty(_host.SeriesCreations); Assert.Equal(reads, _host.TimerReads); Assert.Equal(writes, _stateFile.Writes); Assert.Equal(tagWrites, _host.TagWrites.Count); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(owned)); // Turned back on, nothing was lost while it was off. _enabled = true; Assert.Equal(new[] { owned.Id }, (await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); } // Plan: incomplete recordings integration private IncompleteRecordingService NewIncompleteService(IncompleteRecordingSettings settings, IRecordingOwners owners) => new(_host, _log, PlainStateFile.Instance, () => _clock.UtcNow, IncompleteStorePath, () => settings, owners); private IncompleteRecordingStoreData ReadIncompleteStore() => JsonSerializer.Deserialize(CountingStateFile.ReadShared(IncompleteStorePath))!; // The incomplete tests' Storage Wars airing, which FakeRecordingHost.StartRecording describes. private GuideProgram AddAiring(string id, DateTime start) => AddProgram(id, start, "Storage Wars", 3, 7); [Fact] public async Task AutomaticRequest_TakesIncompleteItemOwners() { AddAiring("p1", Start); AddAiring("p2", Start.AddDays(1)); var item = _host.AddItem("/rec/a.ts"); var owners = NewService(); await owners.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); var timer = new ScheduledTimer { TimerId = "t1", ProgramId = "p1", StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }; _host.Timers.Add(timer); var incomplete = NewIncompleteService(new IncompleteRecordingSettings { AutoRecordComplete = true }, owners); // A 20-minute show written for its first 10 minutes, run once a minute until judged. _clock.UtcNow = Start; while (_clock.UtcNow <= timer.EndDate) { var minute = (_clock.UtcNow - Start).TotalMinutes; if (minute < 10 && !_host.ActivePaths.ContainsKey(timer.TimerId)) { _host.StartRecording(timer, "/rec/a.ts", 3, 7); } else if (minute >= 10 && _host.ActivePaths.ContainsKey(timer.TimerId)) { _host.StopRecording(timer); } _host.Write(); await incomplete.RunAsync(CancellationToken.None); _clock.Advance(TimeSpan.FromMinutes(1)); } Assert.Equal(new[] { "p2" }, _host.Scheduled); var request = ReadIncompleteStore().Requests.Single(); Assert.Null(request.RequestedByUserId); Assert.Equal(new[] { Jordan }, request.OwnerUserIds); await owners.SyncAsync(CancellationToken.None); Assert.Equal(new[] { "api-p2" }, (await owners.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); } [Fact] public async Task ExplicitRequest_SecondUserJoins_BothOwnTheTimer() { var source = AddAiring(Guid.NewGuid().ToString("N"), Start); var later = AddAiring(Guid.NewGuid().ToString("N"), Start.AddDays(1)); _clock.UtcNow = Start.AddMinutes(5); var owners = NewService(); var incomplete = NewIncompleteService(new IncompleteRecordingSettings(), owners); var first = await incomplete.RequestCompleteShowingAsync(source.Id, Jordan, CancellationToken.None); var second = await incomplete.RequestCompleteShowingAsync(source.Id, Alex, CancellationToken.None); Assert.Equal(first.Request!.Id, second.Request!.Id); Assert.Equal(new[] { later.Id }, _host.Scheduled); Assert.Equal(new[] { Jordan, Alex }, second.Request.OwnerUserIds); Assert.Equal(new[] { Jordan }, incomplete.OtherOwners(second.Request, Alex, true).Select(o => o.UserId)); await owners.SyncAsync(CancellationToken.None); var timerId = "api-" + later.Id; var lookup = await owners.LookupAsync(new[] { timerId }, Array.Empty(), Array.Empty(), Sam, CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, lookup.Timers[timerId].Select(o => o.UserId)); } // Compat fix M6: a user lookup that fails or can't tell is not a deleted user. [Fact] public async Task GetUserUnavailable_DoesNotPruneRequestOwners() { var source = AddAiring(Guid.NewGuid().ToString("N"), Start); var later = AddAiring(Guid.NewGuid().ToString("N"), Start.AddDays(1)); _clock.UtcNow = Start.AddMinutes(5); var owners = NewService(); var incomplete = NewIncompleteService(new IncompleteRecordingSettings(), owners); await incomplete.RequestCompleteShowingAsync(source.Id, Jordan, CancellationToken.None); // A server whose user lookup can't be bound answers "can't tell" for everyone. _host.UserLookupUnknown = true; var second = await incomplete.RequestCompleteShowingAsync(source.Id, Alex, CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, second.Request!.OwnerUserIds); Assert.Equal(new[] { Jordan, Alex }, ReadIncompleteStore().Requests.Single().OwnerUserIds); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Timers["api-" + later.Id]); _host.UserLookupUnknown = false; await owners.SyncAsync(CancellationToken.None); var timerId = "api-" + later.Id; var lookup = await owners.LookupAsync(new[] { timerId }, Array.Empty(), Array.Empty(), Sam, CancellationToken.None); Assert.Equal(new[] { Jordan, Alex }, lookup.Timers[timerId].Select(o => o.UserId)); } [Fact] public async Task DeletedUser_StillPrunedFromRequestOwners() { var source = AddAiring(Guid.NewGuid().ToString("N"), Start); var later = AddAiring(Guid.NewGuid().ToString("N"), Start.AddDays(1)); _clock.UtcNow = Start.AddMinutes(5); var owners = NewService(); var incomplete = NewIncompleteService(new IncompleteRecordingSettings(), owners); await incomplete.RequestCompleteShowingAsync(source.Id, Jordan, CancellationToken.None); _host.Users.RemoveAll(u => u.Id == Jordan); var second = await incomplete.RequestCompleteShowingAsync(source.Id, Alex, CancellationToken.None); Assert.Equal(new[] { Alex }, second.Request!.OwnerUserIds); Assert.Equal(new[] { Alex }, ReadIncompleteStore().Requests.Single().OwnerUserIds); Assert.Contains(Alex, ReadStore().Timers["api-" + later.Id]); } [Fact] public async Task GetUserThrows_CompleteShowingStillSucceeds() { var source = AddAiring(Guid.NewGuid().ToString("N"), Start); var later = AddAiring(Guid.NewGuid().ToString("N"), Start.AddDays(1)); _clock.UtcNow = Start.AddMinutes(5); var owners = NewService(); var incomplete = NewIncompleteService(new IncompleteRecordingSettings(), owners); await incomplete.RequestCompleteShowingAsync(source.Id, Jordan, CancellationToken.None); _host.UserLookupThrows = true; var second = await incomplete.RequestCompleteShowingAsync(source.Id, Alex, CancellationToken.None); Assert.Equal(CompleteShowingRefusal.None, second.Refusal); Assert.Equal(new[] { Jordan, Alex }, second.Request!.OwnerUserIds); Assert.Empty(incomplete.OtherOwners(second.Request, Alex, true)); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Timers["api-" + later.Id]); Assert.Contains(_log.Entries, e => e.Kind == LogKind.Warn && e.Message.Contains("still exists")); // The owners endpoints carry on too: owners whose user can't be read are left out, not an error. var lookup = await owners.LookupAsync(new[] { "api-" + later.Id }, Array.Empty(), Array.Empty(), Sam, CancellationToken.None); Assert.Empty(lookup.Timers); } [Fact] public async Task OldStore_RequestedByUserId_SeedsOwnerList() { var source = AddAiring(Guid.NewGuid().ToString("N"), Start); var later = AddAiring(Guid.NewGuid().ToString("N"), Start.AddDays(1)); var data = new IncompleteRecordingStoreData(); data.Requests.Add(new CompleteShowingRequest { Episode = source.Key!, OpenedAt = Start, Explicit = true, RequestedByUserId = Jordan }); // A file from before requests had owners: no OwnerUserIds at all. var json = JsonSerializer.SerializeToNode(data)!; foreach (var request in json["Requests"]!.AsArray()) { Assert.True(request!.AsObject().Remove("OwnerUserIds")); } Directory.CreateDirectory(_dir); File.WriteAllText(IncompleteStorePath, json.ToJsonString()); _clock.UtcNow = Start.AddMinutes(5); var owners = NewService(); var incomplete = NewIncompleteService(new IncompleteRecordingSettings(), owners); await incomplete.RunAsync(CancellationToken.None); Assert.Equal(new[] { later.Id }, _host.Scheduled); var saved = ReadIncompleteStore().Requests.Single(); Assert.Equal(new[] { Jordan }, saved.OwnerUserIds); Assert.Equal(new[] { Jordan }, incomplete.OtherOwners(saved, Alex, true).Select(o => o.UserId)); await owners.SyncAsync(CancellationToken.None); Assert.Equal(new[] { "api-" + later.Id }, (await owners.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); } // Bug 1 regression cases // 1 [Fact] public async Task ItemAddedBeforePathCaptured_SyncAttachesOwnersAndTags() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); _host.StartRecording(TimerOf("p1"), "/rec/a.ts", 1, 1); // Jellyfin adds the item when the recording starts, before any sync saw the file. var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); Assert.Empty(item.Tags); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); } // 2 [Fact] public async Task RecordNow_ItemExistsAtSchedule_RecordProgramAttachesOwners() { AddProgram("p1", Start); LibraryItem? item = null; _host.TimerScheduled = timer => { _host.StartRecording(timer, "/rec/a.ts", 1, 1); item = _host.AddItem("/rec/a.ts"); }; var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); Assert.NotNull(item); Assert.Equal(new[] { Jordan }, ReadStore().Items[item!.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); } // 3 [Fact] public async Task CancelWithActivePath_ItemExists_TakesOwnersAndTimerIsForgotten() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); var timer = TimerOf("p1"); timer.Status = "InProgress"; LibraryItem item; await using (await StartWatcher(service, expectedReads: 2)) { Assert.False(ReadStore().TimerPaths.ContainsKey("api-p1")); // The server raises the cancel (service id) while the recording still runs. _host.ActivePaths[timer.TimerId] = "/rec/a.ts"; item = _host.AddItem("/rec/a.ts"); _host.RaiseTimerCancelled(timer.TimerId); await WaitFor(() => item.Tags.Contains("Recorded by Jordan"), "the cancelled recording's owners"); await Bounded(service.GetMineAsync(Jordan, CancellationToken.None), "a call after the cancel"); var saved = ReadStore(); Assert.Equal(new[] { Jordan }, saved.Items[item.Id]); // The item took the owners once and the timer, cancelled, is done with. Assert.Empty(saved.Timers); Assert.Empty(saved.TimerPaths); } _host.Timers.Remove(timer); _host.ActivePaths.Remove(timer.TimerId); await service.SyncAsync(CancellationToken.None); var after = ReadStore(); Assert.Equal(new[] { Jordan }, after.Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); } // 4 [Fact] public async Task CancelWithActivePath_NoItemYet_LaterItemAddedTakesOwners() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); await service.OnTimerCancelledAsync("t-p1", "/rec/a.ts", CancellationToken.None); var saved = ReadStore(); Assert.Equal(new[] { Jordan }, saved.Timers["api-p1"]); Assert.Equal("/rec/a.ts", saved.TimerPaths["api-p1"]); var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); } // 5 [Fact] public async Task CancelWithNoPath_ForgetsOwners() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); await service.OnTimerCancelledAsync("t-p1", null, CancellationToken.None); var saved = ReadStore(); Assert.Empty(saved.Timers); Assert.Empty(saved.TimerServiceIds); Assert.Empty((await service.GetMineAsync(Alex, CancellationToken.None)).TimerIds); } // 6 [Fact] public async Task CancelEventWithApiId_WatcherMapsServiceIdAndCapturesPath() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); var timer = TimerOf("p1"); timer.Status = "InProgress"; await using (var watcher = await StartWatcher(service, expectedReads: 2)) { // The id map is filled right after the second listing, outside the service's lock. await WaitFor(() => watcher.Watcher.KnowsServiceId("api-p1"), "the watcher's id map"); // Only the service id knows the file, and the event carries the API id. _host.ActivePaths[timer.TimerId] = "/rec/a.ts"; Assert.Null(_host.GetActiveRecordingPath(timer.ApiId!)); _host.RaiseTimerCancelled(timer.ApiId!); await WaitFor(() => File.Exists(StorePath) && ReadStore().TimerPaths.ContainsKey("api-p1"), "the cancelled timer's file"); Assert.Equal("/rec/a.ts", ReadStore().TimerPaths["api-p1"]); Assert.Equal(new[] { Jordan }, ReadStore().Timers["api-p1"]); } var item = _host.AddItem("/rec/a.ts"); await service.OnItemAddedAsync(item, CancellationToken.None); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); } // 7 [Fact] public async Task SyncAttachesOwnersBeforeForgettingFinishedTimer() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); var timer = TimerOf("p1"); _host.StartRecording(timer, "/rec/a.ts", 1, 1); await service.SyncAsync(CancellationToken.None); Assert.Equal("/rec/a.ts", ReadStore().TimerPaths["api-p1"]); // The recording finished and left the listing; its item is there but was never attached. _host.StopRecording(timer); _host.Timers.Remove(timer); var item = _host.AddItem("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); var saved = ReadStore(); Assert.Empty(saved.Timers); Assert.Equal(new[] { Jordan }, saved.Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); } // 8 [Fact] public async Task JoinInProgress_ItemGainsOnlyNewOwnerWithOneTagWrite() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); _host.StartRecording(TimerOf("p1"), "/rec/a.ts", 1, 1); var item = _host.AddItem("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { "Recorded by Jordan" }, TagsOf(item)); var before = _host.TagWrites.Count; var joined = await service.RecordProgramAsync("p1", Alex, CancellationToken.None); Assert.True(joined!.Joined); Assert.Equal(new[] { (item.Id, "Recorded by Alex", true) }, _host.TagWrites.Skip(before)); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Items[item.Id]); before = _host.TagWrites.Count; await service.ClaimAsync(OwnedKind.Timer, "api-p1", Sam, CancellationToken.None); Assert.Equal(new[] { (item.Id, "Recorded by Sam", true) }, _host.TagWrites.Skip(before)); Assert.Equal(new[] { Jordan, Alex, Sam }, ReadStore().Items[item.Id]); Assert.Equal(new[] { "Recorded by Jordan", "Recorded by Alex", "Recorded by Sam" }, TagsOf(item)); } // 9 [Fact] public async Task RepeatedSyncs_AfterAttach_NoExtraTagWritesOrSaves() { AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); _host.StartRecording(TimerOf("p1"), "/rec/a.ts", 1, 1); _host.AddItem("/rec/a.ts"); await service.SyncAsync(CancellationToken.None); var tagWrites = _host.TagWrites.Count; var saves = _stateFile.Writes; for (var i = 0; i < 3; i++) { await service.SyncAsync(CancellationToken.None); } Assert.Equal(tagWrites, _host.TagWrites.Count); Assert.Equal(saves, _stateFile.Writes); } // 10 [Fact] public async Task TimerCreated_WatcherSyncsAgainAfterFollowUpDelay() { var service = NewService(); // The test decides when the follow-up delay is over, so no wall-clock time is involved. var requested = new System.Collections.Concurrent.ConcurrentQueue(); var followUpOver = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); Task FollowUpDelay(TimeSpan delay, CancellationToken ct) { requested.Enqueue(delay); return followUpOver.Task; } await using (await StartWatcher(service, followUpDelay: FollowUpDelay)) { var reads = _host.TimerReads; _host.RaiseTimerCreated(new ScheduledTimer { TimerId = "t-p1", ProgramId = "p1" }); // At once, with a follow-up asked for; idle, the next sync would be ten minutes away. await WaitFor(() => _host.TimerReads >= reads + 1, "the immediate sync"); await WaitFor(() => !requested.IsEmpty, "the follow-up to be scheduled"); Assert.Equal(TimeSpan.FromSeconds(10), Assert.Single(requested)); await Bounded(service.GetMineAsync(Jordan, CancellationToken.None), "a call after the immediate sync"); Assert.Equal(reads + 1, _host.TimerReads); // Once the delay is over, exactly one more sync. followUpOver.SetResult(); await WaitFor(() => _host.TimerReads >= reads + 2, "the follow-up sync"); await Bounded(service.GetMineAsync(Jordan, CancellationToken.None), "a call after the follow-up sync"); Assert.Equal(reads + 2, _host.TimerReads); } } // 11 [Fact] public async Task CancelRaisedUnderServiceLock_DoesNotDeadlock() { AddProgram("p0", Start); AddProgram("p1", Start.AddHours(1)); var service = NewService(); await service.RecordProgramAsync("p0", Jordan, CancellationToken.None); await using (await StartWatcher(service)) { // The schedule call runs inside RecordProgramAsync, under the service's lock, and the // server raises another timer's cancel from it. _host.TimerScheduled = _ => _host.RaiseTimerCancelled("t-p0"); var outcome = await Bounded(Task.Run(() => service.RecordProgramAsync("p1", Alex, CancellationToken.None)), "RecordProgramAsync"); Assert.Equal("api-p1", outcome!.Id); await WaitFor(() => !ReadStore().Timers.ContainsKey("api-p0"), "the cancel to be handled"); Assert.Equal(new[] { Alex }, ReadStore().Timers["api-p1"]); } } // Final fix wave [Fact] public async Task Lookup_ListsVisibleRecordingsOwnedOrNot_InRecordingItemIds() { var owned = _host.AddItem("/rec/owned.ts"); var unowned = _host.AddItem("/rec/unowned.ts"); var hidden = _host.AddItem("/rec/hidden.ts"); var movie = _host.AddItem("/movies/film.mkv"); _host.NotRecordings.Add(movie.Id); _host.HiddenItems.Add(hidden.Id); var service = NewService(); await service.ClaimAsync(OwnedKind.Item, owned.Id.ToString(), Jordan, CancellationToken.None); var lookup = await service.LookupAsync( Array.Empty(), Array.Empty(), new[] { owned.Id, unowned.Id, hidden.Id, movie.Id, Guid.NewGuid() }, Alex, CancellationToken.None); Assert.Equal(new[] { owned.Id, unowned.Id }, lookup.RecordingItemIds); Assert.Equal(new[] { owned.Id }, lookup.Items.Keys); } [Fact] public async Task Lookup_HostCantTellRecordings_LeavesRecordingItemIdsUnknown() { var item = _host.AddItem("/rec/a.ts"); _host.RecordingKindUnknown = true; var service = NewService(); var lookup = await service.LookupAsync(Array.Empty(), Array.Empty(), new[] { item.Id }, Alex, CancellationToken.None); Assert.Null(lookup.RecordingItemIds); } [Fact] public async Task ClaimItem_NotARecording_ReturnsNullAndStampsNothing() { var movie = _host.AddItem("/movies/film.mkv"); _host.NotRecordings.Add(movie.Id); var service = NewService(); var owners = await service.ClaimAsync(OwnedKind.Item, movie.Id.ToString(), Jordan, CancellationToken.None); Assert.Null(owners); Assert.Empty(_host.TagWrites); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); } [Fact] public async Task ClaimItem_HostCantTellRecordings_IsRefusedAndStampsNothing() { var item = _host.AddItem("/rec/a.ts"); _host.RecordingKindUnknown = true; var service = NewService(); var owners = await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); Assert.Null(owners); Assert.Empty(_host.TagWrites); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); } [Fact] public async Task RecordProgram_ServerRefuses_CarriesTheServersReason() { AddProgram("p1", Start); _host.SchedulingError = "Emby Premiere required to record"; var service = NewService(); var attempt = await service.TryRecordProgramAsync("p1", Jordan, CancellationToken.None); Assert.Null(attempt.Outcome); Assert.Equal("Emby Premiere required to record", attempt.ErrorOr("fallback")); Assert.Empty(ReadStoreOrEmpty().Timers); } [Fact] public async Task RecordSeries_ServerRefuses_CarriesTheServersReason() { AddProgram("p1", Start); _host.SeriesCreationError = "Emby Premiere required to record"; var service = NewService(); var attempt = await service.TryRecordSeriesAsync("p1", Jordan, null, CancellationToken.None); Assert.Null(attempt.Outcome); Assert.Equal("Emby Premiere required to record", attempt.ErrorOr("fallback")); } [Fact] public async Task RecordProgram_FailsWithoutReason_FallsBack() { AddProgram("p1", Start); _host.SchedulingFails = true; var service = NewService(); var attempt = await service.TryRecordProgramAsync("p1", Jordan, CancellationToken.None); Assert.Null(attempt.Outcome); Assert.Equal("fallback", attempt.ErrorOr("fallback")); } [Fact] public async Task GetUsersThrows_RecordStillSchedulesAndOwns() { AddProgram("p1", Start); _host.UserLookupThrows = true; // The first call of a new process loads the store, which lists the users. var service = NewService(); var outcome = await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); Assert.NotNull(outcome); Assert.Equal("api-p1", outcome!.Id); Assert.Equal(new[] { "p1" }, _host.Scheduled); Assert.Equal(new[] { Jordan }, ReadStore().Timers["api-p1"]); Assert.Equal(new[] { "api-p1" }, (await service.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); Assert.Contains(_log.Entries, e => e.Kind == LogKind.Warn && e.Message.Contains("list the server's users")); } // PR review fixes [Fact] public async Task ClaimTimer_ProgramHiddenFromCaller_ClaimsNothingAndShowsNoOwners() { var program = AddProgram("p1", Start); var service = NewService(); await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); _host.HiddenItems.Add(program.ItemId); var claimed = await service.ClaimAsync(OwnedKind.Timer, "api-p1", Alex, CancellationToken.None); Assert.Null(claimed); Assert.Equal(new[] { Jordan }, ReadStore().Timers["api-p1"]); } [Fact] public async Task ClaimSeries_NothingTheRuleRecordsIsVisibleToCaller_ClaimsNothing() { var program = AddProgram("p1", Start); _host.SeriesRules.Add(new SeriesRule("rule-a", null, "Bonanza")); _host.Timers.Add(new ScheduledTimer { ApiId = "api-1", TimerId = "t-1", ProgramId = "p1", SeriesTimerId = "rule-a", StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }); _host.HiddenItems.Add(program.ItemId); var service = NewService(); var claimed = await service.ClaimAsync(OwnedKind.Series, "rule-a", Alex, CancellationToken.None); Assert.Null(claimed); Assert.Empty((await service.GetMineAsync(Alex, CancellationToken.None)).SeriesTimerIds); } [Fact] public async Task ClaimSeries_RuleWithNoTimersAndNothingToJudgeBy_ClaimsNothing() { _host.SeriesRules.Add(new SeriesRule("rule-a", null, "Bonanza")); var service = NewService(); Assert.Null(await service.ClaimAsync(OwnedKind.Series, "rule-a", Alex, CancellationToken.None)); } [Fact] public async Task ClaimSeries_RuleWithNoTimers_JudgedByItsChannel() { var visible = Guid.NewGuid(); var hidden = Guid.NewGuid(); _host.SeriesRules.Add(new SeriesRule("rule-a", null, "Bonanza", null, visible.ToString("N"))); _host.SeriesRules.Add(new SeriesRule("rule-b", null, "Rawhide", null, hidden.ToString("N"))); _host.HiddenItems.Add(hidden); var service = NewService(); Assert.NotNull(await service.ClaimAsync(OwnedKind.Series, "rule-a", Alex, CancellationToken.None)); Assert.Null(await service.ClaimAsync(OwnedKind.Series, "rule-b", Alex, CancellationToken.None)); } [Fact] public async Task RecordProgram_OnlyACompletedTimerForIt_SchedulesInsteadOfJoining() { AddProgram("p1", Start); _host.Timers.Add(new ScheduledTimer { ApiId = "api-done", TimerId = "t-done", ProgramId = "p1", StartDate = Start, EndDate = Start.AddMinutes(20), Status = "Completed" }); var service = NewService(); var outcome = await service.RecordProgramAsync("p1", Jordan, CancellationToken.None); Assert.NotNull(outcome); Assert.False(outcome!.Joined); Assert.Equal(new[] { "p1" }, _host.Scheduled); } [Fact] public async Task RecordSeries_SameNameDifferentSeriesId_GetsItsOwnRule() { AddProgram("p1", Start); var other = AddProgram("p2", Start.AddHours(1)); other.SeriesId = "SH999"; var service = NewService(); var first = await service.RecordSeriesAsync("p1", Jordan, null, CancellationToken.None); _host.Timers.Add(new ScheduledTimer { ApiId = "api-s1", TimerId = "t-s1", ProgramId = "p1", SeriesTimerId = first!.Id, StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }); var second = await service.RecordSeriesAsync("p2", Alex, null, CancellationToken.None); Assert.NotNull(second); Assert.False(second!.Joined); Assert.NotEqual(first.Id, second.Id); Assert.Equal(2, _host.SeriesRules.Count); Assert.Equal(new[] { Jordan }, ReadStore().SeriesTimers[first.Id]); } [Fact] public async Task StoreAndBackupBothMissing_RecordingsWithOwnerTags_RebuildsFromTags() { var tagged = _host.AddItem("/rec/a.ts"); tagged.Tags = new[] { "Recorded by Jordan" }; var service = NewService(); var mine = await service.GetMineAsync(Jordan, CancellationToken.None); Assert.Equal(new[] { tagged.Id }, mine.ItemIds); Assert.Equal(new[] { Jordan }, ReadStore().Items[tagged.Id]); Assert.Contains(_log.Entries, e => e.Kind == LogKind.Warn && e.Message.Contains("are missing")); } [Fact] public async Task FirstStart_NoOwnerTags_SavesNothing() { var service = NewService(); Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); Assert.Equal(0, _stateFile.Writes); } [Fact] public async Task RebuildFails_NothingSavedOverTheFiles_NextCallRebuilds() { var tagged = _host.AddItem("/rec/a.ts"); tagged.Tags = new[] { "Recorded by Jordan" }; Directory.CreateDirectory(_dir); File.WriteAllText(StorePath, "{ not json"); File.WriteAllText(StorePath + ".bak", "also not json"); _host.UserLookupThrows = true; var service = NewService(); // A claim made while the rebuild can't run isn't saved over the files the rebuild needs. Assert.Empty((await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); await service.ClaimAsync(OwnedKind.Item, tagged.Id.ToString(), Alex, CancellationToken.None); Assert.Equal(0, _stateFile.Writes); Assert.Equal("{ not json", File.ReadAllText(StorePath)); _host.UserLookupThrows = false; Assert.Equal(new[] { tagged.Id }, (await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); Assert.Equal(new[] { Jordan, Alex }, ReadStore().Items[tagged.Id]); } [Fact] public async Task RebuildFails_RecordMadeMeanwhile_KeepsItsOwnerOnceRebuilt() { var tagged = _host.AddItem("/rec/a.ts"); tagged.Tags = new[] { "Recorded by Jordan" }; AddProgram("p1", Start); Directory.CreateDirectory(_dir); File.WriteAllText(StorePath, "{ not json"); File.WriteAllText(StorePath + ".bak", "also not json"); _host.UserLookupThrows = true; var service = NewService(); var outcome = await service.RecordProgramAsync("p1", Alex, CancellationToken.None); Assert.Equal("api-p1", outcome!.Id); _host.UserLookupThrows = false; Assert.Equal(new[] { "api-p1" }, (await service.GetMineAsync(Alex, CancellationToken.None)).TimerIds); Assert.Equal(new[] { tagged.Id }, (await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); Assert.Equal(new[] { Alex }, ReadStore().Timers["api-p1"]); } [Fact] public async Task SaveFails_NextSyncWritesTheClaim() { var item = _host.AddItem("/rec/a.ts"); var service = NewService(); await service.SyncAsync(CancellationToken.None); _stateFile.FailWrites = true; await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); _stateFile.FailWrites = false; await service.SyncAsync(CancellationToken.None); Assert.Equal(new[] { Jordan }, ReadStore().Items[item.Id]); } [Fact] public async Task RemovedAndReAdded_EventsHandledInArrivalOrder_RecordingsKeepOwners() { var service = NewService(); var items = Enumerable.Range(0, 20).Select(i => _host.AddItem($"/rec/{i}.ts")).ToList(); foreach (var item in items) { await service.ClaimAsync(OwnedKind.Item, item.Id.ToString(), Jordan, CancellationToken.None); } await using (var watcher = await StartWatcher(service)) { // Storage blinks: each recording leaves the library and comes straight back. foreach (var item in items) { _host.RaiseItemRemoved(item.Id); _host.RaiseItemAdded(item); } await Bounded(watcher.Watcher.Idle.ContinueWith(_ => true), "the queued events"); } var saved = ReadStore(); Assert.All(items, item => Assert.Equal(new[] { Jordan }, saved.Items[item.Id])); Assert.Empty(saved.Removed); } [Fact] public async Task SuggestedShowing_ScheduleNamesNoTimer_OwnersStillReachTheTimer() { var source = AddAiring(Guid.NewGuid().ToString("N"), Start); var later = AddAiring(Guid.NewGuid().ToString("N"), Start.AddDays(1)); _clock.UtcNow = Start.AddMinutes(5); _host.ScheduleReturnsNoIds = true; var owners = NewService(); var incomplete = NewIncompleteService(new IncompleteRecordingSettings(), owners); var options = await incomplete.GetCompleteShowingOptionsAsync(source.Id, Jordan); Assert.True(await incomplete.ScheduleSuggestedShowingAsync(source.Id, options.Showing!, Jordan, CancellationToken.None)); await owners.SyncAsync(CancellationToken.None); Assert.Equal(new[] { later.Id }, _host.Scheduled); Assert.Equal(new[] { "api-" + later.Id }, (await owners.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); } [Fact] public async Task RecordSeries_RuleNamedLikeTheSeriesButRecordingAnotherSeriesId_GetsItsOwnRule() { AddProgram("p1", Start); var other = AddProgram("p2", Start.AddHours(1)); other.SeriesId = "SH999"; // As on Jellyfin: the rule carries the series' name but no series id. _host.SeriesRules.Add(new SeriesRule("rule-x", null, "Bonanza")); _host.Timers.Add(new ScheduledTimer { ApiId = "api-x", TimerId = "t-x", ProgramId = "p1", SeriesTimerId = "rule-x", StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }); var service = NewService(); var outcome = await service.RecordSeriesAsync("p2", Alex, null, CancellationToken.None); Assert.NotNull(outcome); Assert.False(outcome!.Joined); Assert.NotEqual("rule-x", outcome.Id); Assert.Equal(2, _host.SeriesRules.Count); } [Fact] public async Task UnnumberedSuggestion_TimerListedLate_OwnerStillReachesIt() { var source = AddProgram(Guid.NewGuid().ToString("N"), Start, "Stephen King: A Necessary Evil", null, null); source.Overview = "Interviews explore the author's work."; var future = AddProgram(Guid.NewGuid().ToString("N"), Start.AddDays(1), source.SeriesName!, null, null); future.Overview = source.Overview; _clock.UtcNow = Start.AddMinutes(5); _host.ScheduleReturnsNoIds = true; _host.ScheduledTimersHidden = true; var owners = NewService(); var incomplete = NewIncompleteService(new IncompleteRecordingSettings(), owners); var options = await incomplete.GetCompleteShowingOptionsAsync(source.Id, Jordan); Assert.False(options.CanSearch); Assert.True(await incomplete.ScheduleSuggestedShowingAsync(source.Id, options.Showing!, Jordan, CancellationToken.None)); Assert.Single(ReadIncompleteStore().PendingTimerOwners); // The next pass that lists the timers again finds it. _host.RevealScheduledTimers(); _clock.Advance(IncompleteRecordingRules.SafetyNetInterval); await incomplete.RunAsync(CancellationToken.None); await owners.SyncAsync(CancellationToken.None); Assert.Equal(new[] { "api-" + future.Id }, (await owners.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); Assert.Empty(ReadIncompleteStore().PendingTimerOwners); } [Fact] public async Task RecordSeries_SameNameRuleWithNoTimersOnAnotherChannel_GetsItsOwnRule() { var program = AddProgram("p1", Start); program.ChannelId = "chan-1"; // As on Jellyfin: no series id and nothing recorded yet, only the name, one channel and // the program it was made from (no longer in the guide). _host.SeriesRules.Add(new SeriesRule("rule-x", null, "Bonanza", "gone", "chan-2")); var service = NewService(); var outcome = await service.RecordSeriesAsync("p1", Alex, null, CancellationToken.None); Assert.NotNull(outcome); Assert.False(outcome!.Joined); Assert.NotEqual("rule-x", outcome.Id); Assert.Equal(2, _host.SeriesRules.Count); } [Fact] public async Task RecordSeries_SameNameRuleWithNoTimersOnTheSameChannel_IsJoined() { var program = AddProgram("p1", Start); program.ChannelId = "chan-1"; _host.SeriesRules.Add(new SeriesRule("rule-x", null, "Bonanza", "gone", "chan-1")); var service = NewService(); var outcome = await service.RecordSeriesAsync("p1", Alex, null, CancellationToken.None); Assert.NotNull(outcome); Assert.True(outcome!.Joined); Assert.Equal("rule-x", outcome.Id); } [Fact] public async Task RecordSeries_SameNameRuleMadeFromAnotherSeriesOnAnyChannel_GetsItsOwnRule() { AddProgram("p1", Start); var made = AddProgram("p0", Start.AddHours(-5)); made.SeriesId = "SH999"; _host.SeriesRules.Add(new SeriesRule("rule-x", null, "Bonanza", "p0", null, true)); var service = NewService(); var outcome = await service.RecordSeriesAsync("p1", Alex, null, CancellationToken.None); Assert.NotNull(outcome); Assert.False(outcome!.Joined); Assert.Equal(2, _host.SeriesRules.Count); } [Fact] public async Task RecordSeries_RuleWithAnUnnumberedTimerAndAnotherSeriesTimer_GetsItsOwnRule() { AddProgram("p1", Start); var other = AddProgram("p2", Start.AddHours(1)); other.SeriesId = "SH999"; var unknown = AddProgram("p3", Start.AddHours(2)); unknown.SeriesId = null; _host.SeriesRules.Add(new SeriesRule("rule-x", null, "Bonanza")); _host.Timers.Add(new ScheduledTimer { ApiId = "api-x1", TimerId = "t-x1", ProgramId = "p1", SeriesTimerId = "rule-x", StartDate = Start, EndDate = Start.AddMinutes(20), Status = "New" }); _host.Timers.Add(new ScheduledTimer { ApiId = "api-x3", TimerId = "t-x3", ProgramId = "p3", SeriesTimerId = "rule-x", StartDate = Start.AddHours(2), EndDate = Start.AddHours(2).AddMinutes(20), Status = "New" }); var service = NewService(); var outcome = await service.RecordSeriesAsync("p2", Alex, null, CancellationToken.None); Assert.False(outcome!.Joined); Assert.NotEqual("rule-x", outcome.Id); } private sealed class FlakyOwners : IRecordingOwners { private readonly IRecordingOwners _inner; public FlakyOwners(IRecordingOwners inner) => _inner = inner; public bool Fail { get; set; } public IReadOnlyList OwnersOfItems(IEnumerable itemIds) => _inner.OwnersOfItems(itemIds); public void AddTimerOwners(string timerId, IEnumerable owners) { if (Fail) { throw new IOException("owners unavailable"); } _inner.AddTimerOwners(timerId, owners); } } [Theory] [InlineData(true)] [InlineData(false)] public async Task SuggestedShowing_HandOverFails_RetriedOnTheNextPass(bool numbered) { var source = numbered ? AddAiring(Guid.NewGuid().ToString("N"), Start) : AddProgram(Guid.NewGuid().ToString("N"), Start, "Stephen King: A Necessary Evil", null, null); source.Overview = "Interviews explore the author's work."; var future = numbered ? AddAiring(Guid.NewGuid().ToString("N"), Start.AddDays(1)) : AddProgram(Guid.NewGuid().ToString("N"), Start.AddDays(1), source.SeriesName!, null, null); future.Overview = source.Overview; _clock.UtcNow = Start.AddMinutes(5); var owners = NewService(); var flaky = new FlakyOwners(owners) { Fail = true }; var incomplete = NewIncompleteService(new IncompleteRecordingSettings(), flaky); var options = await incomplete.GetCompleteShowingOptionsAsync(source.Id, Jordan); Assert.True(await incomplete.ScheduleSuggestedShowingAsync(source.Id, options.Showing!, Jordan, CancellationToken.None)); await owners.SyncAsync(CancellationToken.None); Assert.Empty((await owners.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); flaky.Fail = false; await incomplete.RunAsync(CancellationToken.None); await owners.SyncAsync(CancellationToken.None); Assert.Equal(new[] { "api-" + future.Id }, (await owners.GetMineAsync(Jordan, CancellationToken.None)).TimerIds); } [Fact] public async Task RebuildFails_FileReadableAgain_KeepsOwnersRecordedMeanwhile() { var tagged = _host.AddItem("/rec/a.ts"); tagged.Tags = new[] { "Recorded by Jordan" }; AddProgram("p1", Start); Directory.CreateDirectory(_dir); File.WriteAllText(StorePath, "{ not json"); File.WriteAllText(StorePath + ".bak", "also not json"); _host.UserLookupThrows = true; var service = NewService(); await service.RecordProgramAsync("p1", Alex, CancellationToken.None); // The storage comes back with a good copy before the rebuild gets to run. File.WriteAllText(StorePath, JsonSerializer.Serialize(new OwnershipStoreData { Items = { [tagged.Id] = new List { Jordan } } })); _host.UserLookupThrows = false; Assert.Equal(new[] { "api-p1" }, (await service.GetMineAsync(Alex, CancellationToken.None)).TimerIds); Assert.Equal(new[] { tagged.Id }, (await service.GetMineAsync(Jordan, CancellationToken.None)).ItemIds); Assert.Equal(new[] { Alex }, ReadStore().Timers["api-p1"]); } private OwnershipStoreData ReadStoreOrEmpty() => _stateFile.LastWritten(StorePath) is { } json ? JsonSerializer.Deserialize(json)! : new OwnershipStoreData(); }