public async Task CreateScope_ScopeCreated(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var svc = scope.ServiceProvider.GetRequiredService <IProcessLock>();
var processName = Guid.NewGuid().ToString();
ProcessLockScope pls = null;
(await svc.Exists(processName)).Should().BeFalse();
using (pls = svc.BeginScope(processName))
{
pls.Token.Should().NotBeNull();
pls.IsLocked.Should().BeTrue();
(await svc.Exists(processName)).Should().BeTrue();
}
(await svc.Exists(processName)).Should().BeFalse();
}
}
public async Task CreateOverExpiredRenewedLock_LockCreated(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var svc = scope.ServiceProvider.GetRequiredService <IProcessLock>();
var processName = Guid.NewGuid().ToString();
var token = await svc.Create(processName, 250);
token.Should().NotBeNull();
await Task.Delay(100);
(await svc.Renew(token, 250, 250)).Should().BeTrue();
await Task.Delay(500);
var newToken = await svc.Create(processName, 500);
newToken.Should().NotBeNull();
}
}
protected void CheckIfSkipped(IntegrationTestServerType serverType)
{
if (serverType == IntegrationTestServerType.SqlServer && Config["Environment"] != "Development")
{
throw new SkipException($"{serverType} is disabled for testing in this environment");
}
}
public async Task CreateLock_RecordCreated(IntegrationTestServerType serverType, bool readByToken)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var pl = scope.ServiceProvider.GetRequiredService <DatabaseProcessLockRepository>();
var processName = Guid.NewGuid().ToString();
var token = Guid.NewGuid().ToString();
var expiresOn = DateTime.UtcNow.AddMinutes(15);
var lockDuration = (int)TimeSpan.FromMinutes(15).TotalMilliseconds;
await pl.Create(new DatabaseProcessLockRecord
{
ProcessName = processName,
Token = token,
ExpiresOn = expiresOn,
LockDuration = lockDuration
});
var persistedRecord = readByToken ? await pl.ReadByToken(token) : await pl.ReadByProcessName(processName);
persistedRecord.ProcessName.Should().Be(processName);
persistedRecord.Token.Should().Be(token);
persistedRecord.ExpiresOn.ToString("yyyy-MM-dd HH:mm:ss").Should().Be(expiresOn.ToString("yyyy-MM-dd HH:mm:ss"));
persistedRecord.LockDuration.Should().Be(lockDuration);
}
}
public async Task ViolateKeyConstraint_ConstraintViolated(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var pl = scope.ServiceProvider.GetRequiredService <DatabaseProcessLockRepository>();
var record = new DatabaseProcessLockRecord
{
ProcessName = Guid.NewGuid().ToString(),
Token = Guid.NewGuid().ToString(),
ExpiresOn = DateTime.UtcNow.AddMinutes(15),
LockDuration = (int)TimeSpan.FromMinutes(15).TotalMilliseconds
};
await pl.Create(record);
try
{
await pl.Create(record);
}
catch (Exception ex)
{
pl.IsUniqueKeyViolatedException(ex).Should().BeTrue();
}
}
}
public async Task CheckLockExists_NotExists(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var svc = scope.ServiceProvider.GetRequiredService <IProcessLock>();
var processName = Guid.NewGuid().ToString();
(await svc.Exists(processName)).Should().BeFalse();
}
}
public async Task CreateLock_LockCreated(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var svc = scope.ServiceProvider.GetRequiredService <IProcessLock>();
var processName = Guid.NewGuid().ToString();
(await svc.Create(processName, 500)).Should().NotBeNull();
}
}
public async Task ResetDatabase_TableNotExists(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var pl = scope.ServiceProvider.GetRequiredService <DatabaseProcessLockRepository>();
await pl.ResetDatabase();
(await pl.DoesTableExist()).Should().BeFalse();
}
}
public async Task RenewLockEarly_LockNotRenewed(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var svc = scope.ServiceProvider.GetRequiredService <IProcessLock>();
var processName = Guid.NewGuid().ToString();
var token = await svc.Create(processName, 500);
token.Should().NotBeNull();
(await svc.Renew(processName, 500, 250)).Should().BeFalse();
}
}
public async Task CreateScope_ExistingLock_NoLock(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var svc = scope.ServiceProvider.GetRequiredService <IProcessLock>();
var processName = Guid.NewGuid().ToString();
await svc.Create(processName, 10000);
using (var pls = svc.BeginScope(processName))
{
pls.Token.Should().BeNull();
pls.IsLocked.Should().BeFalse();
}
}
}
public async Task CheckExpiredLockExists_NotExist(IntegrationTestServerType serverType)
{
CheckIfSkipped(serverType);
using (var scope = CreateScope(serverType))
{
var svc = scope.ServiceProvider.GetRequiredService <IProcessLock>();
var processName = Guid.NewGuid().ToString();
var token = await svc.Create(processName, 50);
token.Should().NotBeNull();
await Task.Delay(100);
(await svc.Exists(processName)).Should().BeFalse();
}
}
protected IServiceScope CreateScope(IntegrationTestServerType serverType)
{
return(serverType == IntegrationTestServerType.SqlServer
? SqlServerServiceProvider.CreateScope()
: SqliteServiceProvider.CreateScope());
}
