aboutsummaryrefslogtreecommitdiff
path: root/tests/Jellyfin.Server.Implementations.Tests/SessionManager/SessionInfoTests.cs
blob: c5b8f661b51239de517d8374612f726cd3a5c6d3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
using System;
using System.Threading.Tasks;
using MediaBrowser.Controller.Session;
using MediaBrowser.Model.Session;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Xunit;

namespace Jellyfin.Server.Implementations.Tests.SessionManager;

public class SessionInfoTests
{
    [Fact]
    public async Task StartAutomaticProgress_SnapshotsClientReportedPosition()
    {
        await using var session = new SessionInfo(Mock.Of<ISessionManager>(), NullLogger.Instance);
        var progressInfo = new PlaybackProgressInfo
        {
            IsPaused = true,
            PositionTicks = 123456789
        };

        session.StartAutomaticProgress(progressInfo);

        Assert.Equal(progressInfo.PositionTicks, session.LastPlaybackCheckInPositionTicks);
    }

    [Fact]
    public async Task AutomaticProgress_AdvancesEstimatedPositionWithoutAdvancingSnapshot()
    {
        var sessionManager = new Mock<ISessionManager>();
        await using var session = new SessionInfo(sessionManager.Object, NullLogger.Instance);
        var automaticProgress = new TaskCompletionSource<long?>(TaskCreationOptions.RunContinuationsAsynchronously);
        const long reportedPositionTicks = 123456789;

        sessionManager
            .Setup(manager => manager.OnPlaybackProgress(It.IsAny<PlaybackProgressInfo>(), true))
            .Callback<PlaybackProgressInfo, bool>((info, _) =>
            {
                session.PlayState.PositionTicks = info.PositionTicks;
                automaticProgress.TrySetResult(info.PositionTicks);
            })
            .Returns(Task.CompletedTask);
        session.PlayState.PositionTicks = reportedPositionTicks;

        session.StartAutomaticProgress(new PlaybackProgressInfo
        {
            PositionTicks = reportedPositionTicks
        });

        var estimatedPositionTicks = await automaticProgress.Task.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
        session.StopAutomaticProgress();

        Assert.Equal(reportedPositionTicks + TimeSpan.TicksPerSecond, estimatedPositionTicks);
        Assert.Equal(estimatedPositionTicks, session.PlayState.PositionTicks);
        Assert.Equal(reportedPositionTicks, session.LastPlaybackCheckInPositionTicks);
    }

    [Fact]
    public async Task StartAutomaticProgress_ReplacesSnapshotOnLaterClientReport()
    {
        await using var session = new SessionInfo(Mock.Of<ISessionManager>(), NullLogger.Instance);
        session.StartAutomaticProgress(new PlaybackProgressInfo
        {
            IsPaused = true,
            PositionTicks = 123456789
        });

        session.StartAutomaticProgress(new PlaybackProgressInfo
        {
            IsPaused = true,
            PositionTicks = 987654321
        });

        Assert.Equal(987654321, session.LastPlaybackCheckInPositionTicks);
    }

    [Fact]
    public async Task StartAutomaticProgress_PreservesExactPausedPosition()
    {
        await using var session = new SessionInfo(Mock.Of<ISessionManager>(), NullLogger.Instance);
        var pausedProgress = new PlaybackProgressInfo
        {
            IsPaused = true,
            PositionTicks = 314159265
        };

        session.StartAutomaticProgress(pausedProgress);

        Assert.Equal(pausedProgress.PositionTicks, session.LastPlaybackCheckInPositionTicks);
    }
}