Expand server tests and enforce coverage

Consolidate server tests under tests/, upgrade them to .NET 10, and add CI coverage thresholds and reports. Expand API and application boundary coverage while fixing related issues in media handling, friend blocking, session crypto, presence, username validation, and local storage.
This commit is contained in:
Artemy
2026-10-24 15:30:32 +07:00
parent 33550d4fc9
commit 2d99c57a3b
161 changed files with 5515 additions and 8419 deletions
@@ -0,0 +1,28 @@
using Govor.Application.PingHandler;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
namespace Govor.Application.Tests.Users;
[TestFixture]
public class PingHandlerServiceTests
{
[Test]
public async Task PingUpdatesLastSeenAndThrottlesRepeatedRequests()
{
using var db = new TestDatabase();
using var cache = new MemoryCache(new MemoryCacheOptions());
var service = new PingHandlerService(db.Context, cache);
var old = DateTime.UtcNow.AddHours(-1);
await db.Context.Users.Where(u => u.Id == db.Alice).ExecuteUpdateAsync(s => s.SetProperty(u => u.WasOnline, old));
var before = DateTime.UtcNow;
await service.Ping(db.Alice);
var updated = await db.Context.Users.AsNoTracking().SingleAsync(u => u.Id == db.Alice);
Assert.That(updated.WasOnline, Is.GreaterThanOrEqualTo(before));
Assert.That(cache.TryGetValue($"LastPing_{db.Alice}", out DateTime _), Is.True);
await db.Context.Users.Where(u => u.Id == db.Alice).ExecuteUpdateAsync(s => s.SetProperty(u => u.WasOnline, old));
var storedBeforeThrottledPing = (await db.Context.Users.AsNoTracking().SingleAsync(u => u.Id == db.Alice)).WasOnline;
await service.Ping(db.Alice);
Assert.That((await db.Context.Users.AsNoTracking().SingleAsync(u => u.Id == db.Alice)).WasOnline, Is.EqualTo(storedBeforeThrottledPing));
}
}
@@ -0,0 +1,48 @@
using Govor.Application.PrivateUserChats;
using Govor.Domain.Common;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Tests.Integration.Users;
[TestFixture]
public class ReaderTests
{
[Test]
public async Task PresenceReturnsPersistedLastSeenOrNullForMissingUser()
{
using var db = new TestDatabase();
var time = new DateTime(2026, 10, 24, 10, 0, 0, DateTimeKind.Utc);
await db.Context.Users.Where(u => u.Id == db.Alice).ExecuteUpdateAsync(s => s.SetProperty(u => u.WasOnline, time));
var reader = new UserPresenceReader(db.Context);
Assert.That(await reader.GetLastSeenAsync(db.Alice), Is.EqualTo(time));
Assert.That(await reader.GetLastSeenAsync(Guid.NewGuid()), Is.Null);
Assert.That(await reader.GetLastSeenAsync(Guid.Empty), Is.Null);
}
[Test]
public async Task PrivateChatReaderFiltersBothPositionsAndHandlesMissingChat()
{
using var db = new TestDatabase();
var reader = new UserPrivateChatsGetter(db.Context);
Assert.That((await reader.GetUserChatsAsync(db.Alice)).Select(c => c.Id), Is.EqualTo(new[] { db.ChatId }));
Assert.That((await reader.GetUserChatsAsync(db.Bob)).Select(c => c.Id), Is.EqualTo(new[] { db.ChatId }));
Assert.That(await reader.GetUserChatsAsync(db.Outsider), Is.Empty);
Assert.That((await reader.GetPrivateChatAsync(db.ChatId)).Value.Id, Is.EqualTo(db.ChatId));
Assert.That((await reader.GetPrivateChatAsync(Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That(await reader.ExistChatAsync(db.Alice, db.Bob), Is.True);
Assert.That(await reader.ExistChatAsync(db.Bob, db.Alice), Is.True);
Assert.That(await reader.ExistChatAsync(db.Alice, db.Outsider), Is.False);
}
[Test]
public async Task UsernameExistenceHandlesBlankUnknownAndExistingUsernames()
{
using var db = new TestDatabase();
var validator = new Govor.Application.Users.UserNameExistValidator(db.Context);
Assert.That(await validator.IsUsernameExistsAsync(" "), Is.False);
Assert.That(await validator.IsUsernameExistsAsync(null!), Is.False);
Assert.That(await validator.IsUsernameExistsAsync("missing"), Is.False);
Assert.That(await validator.IsUsernameExistsAsync(db.Alice.ToString()), Is.True);
}
}
@@ -0,0 +1,135 @@
using Govor.Application.Users.UserSessions.Crypto;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Integration.Users;
[TestFixture]
public class SessionCryptoTests
{
private TestDatabase _db = null!;
private SessionKeyAttacher _attacher = null!;
private SessionKeysReader _reader = null!;
private OneTimePreKeysRotator _rotator = null!;
private Mock<ICurrentUserService> _current = null!;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_current = new Mock<ICurrentUserService>();
_current.Setup(c => c.GetCurrentUserId()).Returns(_db.Alice);
_attacher = new(NullLogger<SessionKeyAttacher>.Instance, _current.Object, _db.Context);
_reader = new(NullLogger<SessionKeyAttacher>.Instance, _db.Context);
_rotator = new(NullLogger<SessionKeyAttacher>.Instance, _current.Object, _db.Context);
}
[TearDown] public void TearDown() => _db.Dispose();
private async Task<UserSession> Session(Guid? user = null, bool revoked = false, bool expired = false)
{
var session = new UserSession { UserId = user ?? _db.Alice, RefreshTokenHash = Guid.NewGuid().ToString(),
ExpiresAt = DateTime.UtcNow.AddDays(expired ? -1 : 1), IsRevoked = revoked };
_db.Context.UserSessions.Add(session);
await _db.Context.SaveChangesAsync();
return session;
}
private Task Attach(Guid id) => _attacher.AttachKeysAsync(id, new byte[] { 1 }, new byte[] { 2 },
new byte[] { 3 }, new[] { new byte[] { 4 }, new byte[] { 5 } });
[Test]
public async Task AttachesIdentitySignedAndOneTimeKeysAndReadsThemFromDatabase()
{
var session = await Session();
Assert.That(await _reader.HasKeysAttachedAsync(session.Id), Is.False);
await Attach(session.Id);
_db.Context.ChangeTracker.Clear();
Assert.That(await _reader.HasKeysAttachedAsync(session.Id), Is.True);
var keys = (await _reader.GetAllActiveKeysAsync(_db.Alice)).Single();
Assert.Multiple(() =>
{
Assert.That(keys.UserSessionId, Is.EqualTo(session.Id));
Assert.That(keys.PublicIdentityKey, Is.EqualTo(new byte[] { 1 }));
Assert.That(keys.SignedPreKey.PublicSignedPreKey, Is.EqualTo(new byte[] { 2 }));
Assert.That(keys.SignedPreKey.SignedPreKeySignature, Is.EqualTo(new byte[] { 3 }));
Assert.That(keys.OneTimePreKeys.Select(k => k.PublicKey[0]), Is.EquivalentTo(new byte[] { 4, 5 }));
});
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(2));
var bySession = await _reader.GetKeysBySessionIdAsync(session.Id);
Assert.That(bySession!.UserSession.Id, Is.EqualTo(session.Id));
Assert.That(bySession.OneTimePreKeys.Count, Is.EqualTo(2));
Assert.That(bySession.SignedPreKey, Is.Not.Null);
}
[Test]
public async Task CannotReplaceAttachedKeysOrAttachToAnotherUsersSession()
{
var own = await Session();
var other = await Session(_db.Bob);
await Attach(own.Id);
Assert.ThrowsAsync<InvalidOperationException>(() => Attach(own.Id));
Assert.ThrowsAsync<InvalidOperationException>(() => Attach(other.Id));
Assert.ThrowsAsync<ArgumentException>(() => Attach(Guid.NewGuid()));
Assert.That(await _reader.HasKeysAttachedAsync(other.Id), Is.False);
}
[Test]
public async Task ActiveKeysExcludeExpiredRevokedAndOtherUsersSessions()
{
var active = await Session();
var expired = await Session(expired: true);
var revoked = await Session(revoked: true);
var bob = await Session(_db.Bob);
foreach (var session in new[] { active, expired, revoked }) await Attach(session.Id);
_current.Setup(c => c.GetCurrentUserId()).Returns(_db.Bob);
await Attach(bob.Id);
_db.Context.ChangeTracker.Clear();
Assert.That((await _reader.GetAllActiveKeysAsync(_db.Alice)).Select(k => k.UserSessionId), Is.EqualTo(new[] { active.Id }));
Assert.That((await _reader.GetAllActiveKeysAsync(_db.Bob)).Select(k => k.UserSessionId), Is.EqualTo(new[] { bob.Id }));
}
[Test]
public async Task UsedKeyIsIdempotentAndRotationDeletesOnlyUsedKeys()
{
var session = await Session();
await Attach(session.Id);
var keys = await _db.Context.OneTimePreKeys.OrderBy(k => k.Id).ToListAsync();
await _rotator.MarkOneTimePreKeyAsUsedAsync(session.Id, keys[0].Id);
await _rotator.MarkOneTimePreKeyAsUsedAsync(session.Id, keys[0].Id);
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(1));
await _rotator.RotateOneTimePreKeysAsync(session.Id, new[] { new byte[] { 6 } });
_db.Context.ChangeTracker.Clear();
Assert.That(await _db.Context.OneTimePreKeys.AnyAsync(k => k.Id == keys[0].Id), Is.False);
Assert.That(await _db.Context.OneTimePreKeys.AnyAsync(k => k.Id == keys[1].Id), Is.True);
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(2));
await _rotator.RotateOneTimePreKeysAsync(session.Id, Array.Empty<byte[]>());
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(2));
}
[Test]
public async Task AnotherUserCannotRotateOrConsumeKeysOfThisSession()
{
var session = await Session();
await Attach(session.Id);
var key = await _db.Context.OneTimePreKeys.FirstAsync();
_current.Setup(c => c.GetCurrentUserId()).Returns(_db.Bob);
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _rotator.RotateOneTimePreKeysAsync(session.Id, new[] { new byte[] { 9 } }));
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _rotator.MarkOneTimePreKeyAsUsedAsync(session.Id, key.Id));
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(2));
}
[Test]
public async Task MissingSessionAndMismatchedKeyAreRejected()
{
var session = await Session();
await Attach(session.Id);
var key = await _db.Context.OneTimePreKeys.FirstAsync();
Assert.ThrowsAsync<ArgumentException>(() => _rotator.MarkOneTimePreKeyAsUsedAsync(Guid.NewGuid(), key.Id));
Assert.ThrowsAsync<ArgumentException>(() => _rotator.MarkOneTimePreKeyAsUsedAsync(session.Id, Guid.NewGuid()));
Assert.ThrowsAsync<ArgumentException>(() => _rotator.RotateOneTimePreKeysAsync(Guid.NewGuid(), Array.Empty<byte[]>()));
Assert.That(await _reader.GetKeysBySessionIdAsync(Guid.NewGuid()), Is.Null);
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(Guid.NewGuid()), Is.Zero);
}
}
@@ -0,0 +1,105 @@
using Govor.Application.Authentication.JWT;
using Govor.Application.Tests.Support;
using Govor.Application.PushNotifications;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using Moq;
namespace Govor.Application.Tests.Integration.Users;
[TestFixture]
public class UserSessionFailureTests
{
[Test]
public async Task ReaderAndRevokerReturnFailuresWithoutTouchingPushTokensOnDatabaseErrors()
{
using var db = new TestDatabase();
var session = new UserSession { UserId = db.Alice, RefreshTokenHash = "hash", ExpiresAt = DateTime.UtcNow.AddDays(1) };
db.Context.UserSessions.Add(session);
await db.Context.SaveChangesAsync();
using var failed = db.CreateContext(new FailDatabaseCommand());
var push = new Mock<IPushTokenService>(MockBehavior.Strict);
var reader = new UserSessionReader(failed, NullLogger<UserSessionReader>.Instance);
var revoker = new UserSessionRevoker(failed, push.Object, NullLogger<UserSessionRevoker>.Instance);
Assert.That((await reader.GetAllSessionsAsync(db.Alice)).IsFailure, Is.True);
Assert.That((await revoker.CloseSessionByIdAsync(session.Id, db.Alice)).IsFailure, Is.True);
Assert.That((await revoker.CloseAllSessionsAsync(db.Alice)).IsFailure, Is.True);
push.VerifyNoOtherCalls();
Assert.That((await db.Context.UserSessions.AsNoTracking().SingleAsync()).IsRevoked, Is.False);
}
[Test]
public async Task OpeningSessionStopsAfterReaderFailure()
{
using var db = new TestDatabase();
var reader = new Mock<IUserSessionReader>();
var error = Error.ServerError("Sessions.Unavailable", "unavailable");
reader.Setup(r => r.GetAllSessionsAsync(db.Alice)).ReturnsAsync(Result.Failure<List<UserSession>>(error));
var jwt = new Mock<IJwtService>(MockBehavior.Strict);
var opener = new UserSessionOpener(NullLogger<UserSessionOpener>.Instance, reader.Object, db.Context,
Mock.Of<IJwtTokenHasher>(), Options.Create(new JwtRefreshOption()), jwt.Object);
var result = await opener.OpenSessionAsync(await db.Context.Users.SingleAsync(u => u.Id == db.Alice), "phone");
Assert.That(result.Error, Is.SameAs(error));
jwt.VerifyNoOtherCalls();
Assert.That(await db.Context.UserSessions.CountAsync(), Is.Zero);
}
[Test]
public async Task FailedSessionInsertReturnsFailureAndLeavesNoSession()
{
using var db = new TestDatabase();
using var failed = db.CreateContext(new FailDatabaseCommand(sql => sql.Contains("INSERT INTO \"UserSessions\"", StringComparison.Ordinal)));
var reader = new UserSessionReader(failed, NullLogger<UserSessionReader>.Instance);
var jwt = new Mock<IJwtService>();
jwt.Setup(j => j.GenerateAccessTokenAsync(It.IsAny<User>(), It.IsAny<Guid>())).ReturnsAsync("access");
jwt.Setup(j => j.GenerateRefreshTokenAsync(It.IsAny<User>())).ReturnsAsync("refresh");
var hash = new Mock<IJwtTokenHasher>();
hash.Setup(h => h.HashToken("refresh")).Returns("hash");
var opener = new UserSessionOpener(NullLogger<UserSessionOpener>.Instance, reader, failed, hash.Object,
Options.Create(new JwtRefreshOption { RefreshTokenLifetimeDays = 30 }), jwt.Object);
Assert.That((await opener.OpenSessionAsync(await db.Context.Users.SingleAsync(u => u.Id == db.Alice), null!)).IsFailure, Is.True);
Assert.That(await db.Context.UserSessions.CountAsync(), Is.Zero);
}
[Test]
public async Task RefreshDatabaseFailureReturnsFailure()
{
using var db = new TestDatabase();
using var failed = db.CreateContext(new FailDatabaseCommand());
var hash = Mock.Of<IJwtTokenHasher>(h => h.HashToken("token") == "hash");
var service = new UserSessionRefresher(NullLogger<UserSessionRefresher>.Instance,
Options.Create(new JwtRefreshOption()), hash, Mock.Of<IJwtService>(), failed);
Assert.That((await service.RefreshTokenAsync("token")).IsFailure, Is.True);
}
[Test]
public async Task RevocationBetweenTokenLookupAndRotationRejectsRefresh()
{
using var db = new TestDatabase();
var session = new UserSession { UserId = db.Alice, RefreshTokenHash = "old-hash", ExpiresAt = DateTime.UtcNow.AddDays(1) };
db.Context.UserSessions.Add(session);
await db.Context.SaveChangesAsync();
var jwt = new Mock<IJwtService>();
jwt.Setup(j => j.GenerateAccessTokenAsync(It.IsAny<User>(), session.Id)).ReturnsAsync("access");
jwt.Setup(j => j.GenerateRefreshTokenAsync(It.IsAny<User>())).Returns(async () =>
{
await db.Context.UserSessions.Where(s => s.Id == session.Id).ExecuteUpdateAsync(s => s.SetProperty(s => s.IsRevoked, true));
return "new";
});
var hash = new Mock<IJwtTokenHasher>();
hash.Setup(h => h.HashToken("old")).Returns("old-hash");
hash.Setup(h => h.HashToken("new")).Returns("new-hash");
using var context = db.CreateContext();
var service = new UserSessionRefresher(NullLogger<UserSessionRefresher>.Instance,
Options.Create(new JwtRefreshOption { RefreshTokenLifetimeDays = 30 }), hash.Object, jwt.Object, context);
var result = await service.RefreshTokenAsync("old");
Assert.That(result.Error.Type, Is.EqualTo(ErrorType.Unauthorized));
var stored = await db.Context.UserSessions.AsNoTracking().SingleAsync();
Assert.That(stored.RefreshTokenHash, Is.EqualTo("old-hash"));
Assert.That(stored.IsRevoked, Is.True);
}
}
@@ -0,0 +1,132 @@
using Govor.Application.Authentication.JWT;
using Govor.Application.Users.UserSessions;
using Govor.Application.PushNotifications;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using Moq;
namespace Govor.Application.Tests.Users;
[TestFixture]
public class UserSessionTests
{
private TestDatabase _db = null!;
private Mock<IJwtService> _jwt = null!;
private Mock<IJwtTokenHasher> _hasher = null!;
private UserSessionReader _reader = null!;
private UserSessionRefresher _refresher = null!;
private UserSessionOpener _opener = null!;
private Mock<IPushTokenService> _push = null!;
private UserSessionRevoker _revoker = null!;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_jwt = new Mock<IJwtService>();
_jwt.Setup(j => j.GenerateAccessTokenAsync(It.IsAny<User>(), It.IsAny<Guid>()))
.ReturnsAsync((User _, Guid sid) => "access-" + sid);
_jwt.Setup(j => j.GenerateRefreshTokenAsync(It.IsAny<User>())).ReturnsAsync(() => Guid.NewGuid().ToString());
_hasher = new Mock<IJwtTokenHasher>();
_hasher.Setup(h => h.HashToken(It.IsAny<string>())).Returns((string token) => "hash-" + token);
_reader = new UserSessionReader(_db.Context, NullLogger<UserSessionReader>.Instance);
var options = Options.Create(new JwtRefreshOption { RefreshTokenLifetimeDays = 30 });
_opener = new UserSessionOpener(NullLogger<UserSessionOpener>.Instance, _reader, _db.Context,
_hasher.Object, options, _jwt.Object);
_refresher = new UserSessionRefresher(NullLogger<UserSessionRefresher>.Instance, options,
_hasher.Object, _jwt.Object, _db.Context);
_push = new Mock<IPushTokenService>();
_push.Setup(p => p.DeactivateTokenBySessionAsync(It.IsAny<Guid>())).ReturnsAsync(Result.Success());
_push.Setup(p => p.DeactivateAllTokensByUserIdAsync(It.IsAny<Guid>())).ReturnsAsync(Result.Success());
_revoker = new UserSessionRevoker(_db.Context, _push.Object, NullLogger<UserSessionRevoker>.Instance);
}
[TearDown] public void TearDown() => _db.Dispose();
private async Task<UserSession> AddSession(Guid user, bool revoked = false, bool expired = false)
{
var session = new UserSession { UserId = user, RefreshTokenHash = "hash-" + Guid.NewGuid(),
ExpiresAt = DateTime.UtcNow.AddDays(expired ? -1 : 1), IsRevoked = revoked, DeviceInfo = "phone" };
_db.Context.UserSessions.Add(session);
await _db.Context.SaveChangesAsync();
return session;
}
[Test]
public async Task SameDeviceLabelStillCreatesDistinctSessionsAndStoresOnlyTokenHashes()
{
var user = await _db.Context.Users.SingleAsync(u => u.Id == _db.Alice);
var first = await _opener.OpenSessionAsync(user, "phone");
var second = await _opener.OpenSessionAsync(user, "phone");
Assert.That(first.IsSuccess && second.IsSuccess, Is.True);
var sessions = await _db.Context.UserSessions.AsNoTracking().ToListAsync();
Assert.That(sessions, Has.Count.EqualTo(2));
Assert.That(sessions.Select(s => s.Id).Distinct().Count(), Is.EqualTo(2));
Assert.That(sessions.Select(s => s.RefreshTokenHash), Is.EquivalentTo(
new[] { "hash-" + first.Value.refreshToken, "hash-" + second.Value.refreshToken }));
Assert.That(sessions.All(s => s.ExpiresAt > DateTime.UtcNow.AddDays(29)), Is.True);
}
[Test]
public async Task ReaderFiltersOwnerAndRevocation()
{
var own = await AddSession(_db.Alice);
await AddSession(_db.Alice, revoked: true);
await AddSession(_db.Bob);
Assert.That((await _reader.GetAllSessionsAsync(_db.Alice)).Value.Select(s => s.Id), Is.EqualTo(new[] { own.Id }));
Assert.That((await _reader.GetAllSessionsAsync(Guid.Empty)).IsFailure, Is.True);
}
[Test]
public async Task RefreshRotatesHashAndRejectsReplay()
{
var session = await AddSession(_db.Alice);
var oldToken = session.RefreshTokenHash["hash-".Length..];
var result = await _refresher.RefreshTokenAsync(oldToken);
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.Value.accessToken, Is.EqualTo("access-" + session.Id));
_db.Context.ChangeTracker.Clear();
Assert.That((await _db.Context.UserSessions.SingleAsync()).RefreshTokenHash,
Is.EqualTo("hash-" + result.Value.refreshToken));
Assert.That((await _refresher.RefreshTokenAsync(oldToken)).IsFailure, Is.True);
}
[TestCase(true, false)]
[TestCase(false, true)]
public async Task RevokedOrExpiredSessionCannotRefresh(bool revoked, bool expired)
{
var session = await AddSession(_db.Alice, revoked, expired);
Assert.That((await _refresher.RefreshTokenAsync(session.RefreshTokenHash["hash-".Length..])).IsFailure, Is.True);
_jwt.Verify(j => j.GenerateRefreshTokenAsync(It.IsAny<User>()), Times.Never);
}
[TestCase("")]
[TestCase(" ")]
[TestCase("unknown")]
public async Task InvalidRefreshTokenReturnsFailure(string token) =>
Assert.That((await _refresher.RefreshTokenAsync(token)).IsFailure, Is.True);
[Test]
public async Task SessionCanBeRevokedOnlyByOwnerAndPushTokenIsDeactivated()
{
var session = await AddSession(_db.Alice);
Assert.That((await _revoker.CloseSessionByIdAsync(session.Id, _db.Bob)).Error.Type, Is.EqualTo(ErrorType.NotFound));
_push.VerifyNoOtherCalls();
Assert.That((await _revoker.CloseSessionByIdAsync(session.Id, _db.Alice)).IsSuccess, Is.True);
Assert.That((await _db.Context.UserSessions.AsNoTracking().SingleAsync()).IsRevoked, Is.True);
_push.Verify(p => p.DeactivateTokenBySessionAsync(session.Id), Times.Once);
}
[Test]
public async Task CloseAllIsIdempotentAndKeepsOtherUsersSessions()
{
await AddSession(_db.Alice);
var bob = await AddSession(_db.Bob);
Assert.That((await _revoker.CloseAllSessionsAsync(_db.Alice)).IsSuccess, Is.True);
Assert.That((await _revoker.CloseAllSessionsAsync(_db.Alice)).IsSuccess, Is.True);
Assert.That((await _db.Context.UserSessions.AsNoTracking().SingleAsync(s => s.Id == bob.Id)).IsRevoked, Is.False);
_push.Verify(p => p.DeactivateAllTokensByUserIdAsync(_db.Alice), Times.Once);
}
}