public void ShouldDisposeScopeAfterJobCompletion()
{
var key = new JobKey("disposable", "grp2");
var job1 = JobBuilder.Create <SampleJob>().WithIdentity(key).StoreDurably(true)
.Build();
var trigger =
TriggerBuilder.Create().WithSimpleSchedule(s => s.WithIntervalInSeconds(1).WithRepeatCount(1)).Build();
var scopesCreated = 0;
var scopesDisposed = 0;
DisposableDependency dependency = null;
_lifetimeScope.ChildLifetimeScopeBeginning += (sender, args) =>
{
scopesCreated++;
dependency = args.LifetimeScope.Resolve <DisposableDependency>();
args.LifetimeScope.CurrentScopeEnding += (o, eventArgs) => { scopesDisposed++; };
};
_scheduler.ScheduleJob(job1, trigger);
_scheduler.Start();
Thread.Sleep(3.Seconds());
_jobFactory.RunningJobs.Should().BeEmpty("Scope was not disposed after job completion");
dependency.Disposed.Should().BeTrue("Dependency must be disposed");
scopesDisposed.Should().Be(scopesCreated, "All scopes must be disposed");
}
public async Task EventHandler_Should_Use_Scoped_Object_In_ForEachAsync_Loop()
{
var snsEvent = new SNSEvent
{
Records = new List <SNSEvent.SNSRecord>
{
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
},
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
}
}
};
var dependency = new DisposableDependency();
var services = new ServiceCollection();
services.AddScoped(_ => dependency);
var tcs = new TaskCompletionSource <TestNotification>();
services.AddTransient <IEventHandler <SNSEvent>, ParallelSnsEventHandler <TestNotification> >();
services.AddTransient <INotificationHandler <TestNotification>,
TestNotificationScopedHandler>(provider => new TestNotificationScopedHandler(provider.GetRequiredService <DisposableDependency>(), tcs));
services.AddSingleton <ISerializer, SystemTextJsonSerializer>();
var sp = services.BuildServiceProvider();
var serializer = sp.GetRequiredService <ISerializer>();
var sqsEventHandler = new ParallelSnsEventHandler <TestNotification>(sp, serializer, new NullLoggerFactory(), Options.Create(new ParallelSnsExecutionOptions {
MaxDegreeOfParallelism = 4
}));
var task = sqsEventHandler.HandleAsync(snsEvent, new TestLambdaContext());
Assert.That(dependency.Disposed, Is.False, "Dependency should not be disposed");
Assert.That(task.IsCompleted, Is.False, "The task should not be completed");
tcs.SetResult(new TestNotification());
await task;
Assert.That(dependency.Disposed, Is.True, "Dependency should be disposed");
Assert.That(task.IsCompleted, Is.True, "The task should be completed");
}
public void should_be_able_to_configure_disposbale_dependency_implementing_interface_by_interface()
{
// Given
var disposableDependency = new DisposableDependency();
// When
new Browser(with =>
with.Dependency <IIinterface>(disposableDependency)
);
// Then
Assert.False(disposableDependency.Disposed);
}
public void When_disposeing_scope_should_dispose_of_all_scope_dependency(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddScoped <Dependency>().AddScoped <DisposableDependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var serviceScopeFactory = (IServiceScopeFactory)serviceProvider.GetService(typeof(IServiceScopeFactory));
//Scope 1
var serviceScope = serviceScopeFactory.CreateScope();
DisposableDependency object1 = (DisposableDependency)serviceScope.ServiceProvider.GetService(typeof(DisposableDependency));
serviceScope.Dispose();
Assert.AreEqual(object1.DisposeCounter, 1);
}
public async Task EventHandler_Should_Use_Scoped_Object_In_ForEach_Loop()
{
var sqsEvent = new SQSEvent
{
Records = new List <SQSEvent.SQSMessage>
{
new SQSEvent.SQSMessage
{
Body = "{}"
},
new SQSEvent.SQSMessage
{
Body = "{}"
},
}
};
var dependency = new DisposableDependency();
var services = new ServiceCollection();
services.AddScoped(_ => dependency);
var tcs = new TaskCompletionSource <TestMessage>();
services.AddTransient <IEventHandler <SQSEvent>, SqsEventHandler <TestMessage> >();
services.AddTransient <IMessageHandler <TestMessage>,
TestMessageScopedHandler>(provider =>
new TestMessageScopedHandler(provider.GetRequiredService <DisposableDependency>(), tcs));
services.AddSingleton <ISerializer, SystemTextJsonSerializer>();
var sp = services.BuildServiceProvider();
var serializer = sp.GetRequiredService <ISerializer>();
var sqsEventHandler = new SqsEventHandler <TestMessage>(sp, serializer, new NullLoggerFactory());
var task = sqsEventHandler.HandleAsync(sqsEvent, new TestLambdaContext());
Assert.That(dependency.Disposed, Is.False, "Dependency should not be disposed");
Assert.That(task.IsCompleted, Is.False, "The task should not be completed");
tcs.SetResult(new TestMessage());
await task;
Assert.That(dependency.Disposed, Is.True, "Dependency should be disposed");
Assert.That(task.IsCompleted, Is.True, "The task should be completed");
}
public void FunctionHandlerAsync_is_awaited_before_disposal()
{
var dependency = new DisposableDependency();
var taskCompletionSource = new TaskCompletionSource <string>();
var sut = new TestEventFunction(dependency, taskCompletionSource);
var result = sut.FunctionHandlerAsync("Hi there", new TestLambdaContext());
Assert.That(dependency.Disposed, Is.False, "Dependency should not be disposed");
Assert.That(result.IsCompleted, Is.False, "The task should not be completed");
taskCompletionSource.SetResult("done");
Assert.That(dependency.Disposed, Is.True, "Dependency should be disposed");
Assert.That(result.IsCompleted, Is.True, "The task should be completed");
}
public TestHandler(DisposableDependency dependency, TaskCompletionSource <string> tcs)
{
_dependency = dependency;
_tcs = tcs;
}
public TestEventFunction(DisposableDependency dependency, TaskCompletionSource <string> tcs)
{
_dependency = dependency;
_tcs = tcs;
}
public UsingStatement()
{
using (var foo = new DisposableDependency())
{
}
}
public TestMessageScopedHandler(DisposableDependency dependency, TaskCompletionSource <TestMessage> tcs)
{
_dependency = dependency;
_tcs = tcs;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object" /> class.
/// </summary>
public SampleJob(DisposableDependency dependency)
{
_dependency = dependency;
}
public void should_be_able_to_configure_disposbale_dependency_implementing_interface_by_interface()
{
// Given
var disposableDependency = new DisposableDependency();
// When
new Browser(with =>
with.Dependency<IIinterface>(disposableDependency)
);
// Then
Assert.False(disposableDependency.Disposed);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object" /> class.
/// </summary>
public SampleJob([NotNull] DisposableDependency dependency)
{
_dependency = dependency ?? throw new ArgumentNullException(nameof(dependency));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object" /> class.
/// </summary>
public SampleJob(DisposableDependency dependency)
{
_dependency = dependency;
}
public TestNotificationScopedHandler(DisposableDependency dependency, TaskCompletionSource <TestNotification> tcs)
{
_dependency = dependency;
_tcs = tcs;
}
