private void InsertPendingCommands(T processManager, string operationId, Guid?correlationId, string contributor)
{
IEnumerable <PendingCommand> pendingCommands = processManager
.FlushPendingCommands()
.Select(command => new Envelope(Guid.NewGuid(), command, operationId, correlationId, contributor))
.Select(envelope => PendingCommand.FromEnvelope(processManager, envelope, _serializer));
_dbContext.PendingCommands.AddRange(pendingCommands);
}
public async Task FlushCommands_sends_all_commands_associated_with_specified_process_manager_sequentially()
{
// Arrange
var serializer = new JsonMessageSerializer();
var processManager = new FakeProcessManager();
var noiseProcessManager = new FakeProcessManager();
var random = new Random();
var fixture = new Fixture();
var envelopes = new List <Envelope>(
from command in new[]
{
new FakeCommand {
Int32Value = random.Next(), StringValue = fixture.Create <string>()
},
new FakeCommand {
Int32Value = random.Next(), StringValue = fixture.Create <string>()
},
new FakeCommand {
Int32Value = random.Next(), StringValue = fixture.Create <string>()
},
}
select new Envelope(Guid.NewGuid(), command, null, Guid.NewGuid(), null));
using (var db = new ProcessManagerDbContext(_dbContextOptions))
{
db.PendingCommands.AddRange(from envelope in envelopes
select PendingCommand.FromEnvelope(processManager, envelope, serializer));
db.PendingCommands.AddRange(from envelope in new[]
{
new Envelope(new object()),
new Envelope(new object()),
new Envelope(new object()),
}
select PendingCommand.FromEnvelope(noiseProcessManager, envelope, serializer));
await db.SaveChangesAsync();
}
var messageBus = new MessageBus();
var sut = new SqlCommandPublisher(
() => new ProcessManagerDbContext(_dbContextOptions),
serializer,
messageBus,
Mock.Of <IScheduledMessageBus>());
// Act
await sut.FlushCommands(processManager.Id, CancellationToken.None);
// Assert
messageBus.Sent.Should().BeEquivalentTo(envelopes, opts => opts.WithStrictOrdering().RespectingRuntimeTypes());
}
public async Task given_message_bus_fails_FlushCommands_deletes_no_command()
{
// Arrange
var serializer = new JsonMessageSerializer();
var processManager = new FakeProcessManager();
var random = new Random();
var commands = new List <PendingCommand>(
from command in new[]
{
new FakeCommand {
Int32Value = random.Next(), StringValue = Guid.NewGuid().ToString()
},
new FakeCommand {
Int32Value = random.Next(), StringValue = Guid.NewGuid().ToString()
},
new FakeCommand {
Int32Value = random.Next(), StringValue = Guid.NewGuid().ToString()
},
}
let envelope = new Envelope(command)
select PendingCommand.FromEnvelope(processManager, envelope, serializer));
using (var db = new ProcessManagerDbContext(_dbContextOptions))
{
db.PendingCommands.AddRange(commands);
await db.SaveChangesAsync();
}
IMessageBus messageBus = Mock.Of <IMessageBus>();
var exception = new InvalidOperationException();
Mock.Get(messageBus)
.Setup(x => x.Send(It.IsAny <IEnumerable <Envelope> >(), It.IsAny <CancellationToken>()))
.ThrowsAsync(exception);
var sut = new SqlCommandPublisher(
() => new ProcessManagerDbContext(_dbContextOptions),
serializer,
messageBus,
Mock.Of <IScheduledMessageBus>());
// Act
Func <Task> action = () => sut.FlushCommands(processManager.Id, CancellationToken.None);
// Assert
action.Should().Throw <InvalidOperationException>().Which.Should().BeSameAs(exception);
using (var db = new ProcessManagerDbContext(_dbContextOptions))
{
IQueryable <PendingCommand> query = from c in db.PendingCommands
where c.ProcessManagerId == processManager.Id
select c;
List <PendingCommand> actual = await query.ToListAsync();
actual.Should().BeEquivalentTo(commands, opts => opts.RespectingRuntimeTypes());
}
}
public void FromEnvelope_sets_CorrelationId_correctly()
{
var fixture = new Fixture();
var envelope = new Envelope(Guid.NewGuid(), fixture.Create <FooCommand>(), correlationId: Guid.NewGuid());
var processManager = new FooProcessManager();
var serializer = new JsonMessageSerializer();
var actual = PendingCommand.FromEnvelope(processManager, envelope, serializer);
actual.CorrelationId.Should().Be(envelope.CorrelationId);
}
public void FromEnvelope_sets_ProcessManagerId_correctly()
{
var fixture = new Fixture();
var envelope = new Envelope(fixture.Create <FooCommand>());
var processManager = new FooProcessManager();
var serializer = new JsonMessageSerializer();
var actual = PendingCommand.FromEnvelope(processManager, envelope, serializer);
TestContext.WriteLine($"{actual.ProcessManagerId}");
actual.ProcessManagerId.Should().Be(processManager.Id);
}
public async Task FlushCommands_absorbs_exception_caused_by_that_some_pending_command_already_deleted_since_loaded()
{
// Arrange
var messageBus = new CompletableMessageBus();
var serializer = new JsonMessageSerializer();
var sut = new SqlCommandPublisher(
() => new ProcessManagerDbContext(_dbContextOptions),
serializer,
messageBus,
Mock.Of <IScheduledMessageBus>());
var processManager = new FakeProcessManager();
using (var db = new ProcessManagerDbContext(_dbContextOptions))
{
db.PendingCommands.AddRange(
new[]
{
new FakeCommand(),
new FakeCommand(),
new FakeCommand(),
}
.Select(c => new Envelope(c))
.Select(e => PendingCommand.FromEnvelope(processManager, e, serializer)));
await db.SaveChangesAsync();
}
// Act
Func <Task> action = async() =>
{
Task flushTask = sut.FlushCommands(processManager.Id, CancellationToken.None);
using (var db = new ProcessManagerDbContext(_dbContextOptions))
{
List <PendingCommand> pendingCommands = await db
.PendingCommands
.Where(c => c.ProcessManagerId == processManager.Id)
.OrderByDescending(c => c.Id)
.Take(1)
.ToListAsync();
db.PendingCommands.RemoveRange(pendingCommands);
await db.SaveChangesAsync();
}
messageBus.Complete();
await flushTask;
};
// Assert
action.Should().NotThrow();
}
public void FromEnvelope_sets_CommandJson_correctly()
{
var fixture = new Fixture();
FooCommand command = fixture.Create <FooCommand>();
var envelope = new Envelope(command);
var processManager = new FooProcessManager();
var serializer = new JsonMessageSerializer();
var actual = PendingCommand.FromEnvelope(processManager, envelope, serializer);
serializer.Deserialize(actual.CommandJson)
.Should().BeOfType <FooCommand>()
.Subject.ShouldBeEquivalentTo(command);
}
public async Task FlushCommands_deletes_all_commands_associated_with_specified_process_manager()
{
// Arrange
var serializer = new JsonMessageSerializer();
var processManager = new FakeProcessManager();
var noiseProcessManager = new FakeProcessManager();
const int noiseCommandCount = 3;
using (var db = new ProcessManagerDbContext(_dbContextOptions))
{
var commands = new List <PendingCommand>(
from command in Enumerable.Repeat(new FakeCommand(), 3)
let envelope = new Envelope(command)
select PendingCommand.FromEnvelope(processManager, envelope, serializer));
commands.AddRange(
from command in Enumerable.Repeat(new FakeCommand(), noiseCommandCount)
let envelope = new Envelope(command)
select PendingCommand.FromEnvelope(noiseProcessManager, envelope, serializer));
var random = new Random();
db.PendingCommands.AddRange(
from command in commands
orderby random.Next()
select command);
await db.SaveChangesAsync();
}
var sut = new SqlCommandPublisher(
() => new ProcessManagerDbContext(_dbContextOptions),
serializer,
Mock.Of <IMessageBus>(),
Mock.Of <IScheduledMessageBus>());
// Act
await sut.FlushCommands(processManager.Id, CancellationToken.None);
// Assert
using (var db = new ProcessManagerDbContext(_dbContextOptions))
{
(await db.PendingCommands.AnyAsync(c => c.ProcessManagerId == processManager.Id)).Should().BeFalse();
(await db.PendingCommands.CountAsync(c => c.ProcessManagerId == noiseProcessManager.Id)).Should().Be(noiseCommandCount);
}
}
public async Task EnqueueAll_publishes_all_pending_commands_asynchronously()
{
// Arrange
var serializer = new JsonMessageSerializer();
var fixture = new Fixture();
using (var db = new FooProcessManagerDbContext())
{
for (int i = 0; i < 3; i++)
{
var processManager = new FooProcessManager();
db.PendingCommands.AddRange(from command in Enumerable.Repeat(new FooCommand(), 3)
let envelope = new Envelope(command)
select PendingCommand.FromEnvelope(processManager, envelope, serializer));
}
await db.SaveChangesAsync();
}
var sut = new SqlCommandPublisher(
() => new FooProcessManagerDbContext(),
serializer,
Mock.Of <IMessageBus>(),
Mock.Of <IScheduledMessageBus>());
// Act
sut.EnqueueAll(CancellationToken.None);
// Assert
using (var db = new FooProcessManagerDbContext())
{
int maximumRetryCount = 5;
var retryPolicy = new RetryPolicy <bool>(
maximumRetryCount,
new DelegatingTransientFaultDetectionStrategy <bool>(any => any == true),
new ConstantRetryIntervalStrategy(TimeSpan.FromSeconds(1.0)));
(await retryPolicy.Run(db.PendingCommands.AnyAsync, CancellationToken.None)).Should().BeFalse();
}
}
public void FromEnvelope_generates_PendingCommand_correctly()
{
// Arrange
var processManager = new FakeProcessManager();
var messageId = Guid.NewGuid();
var correlationId = Guid.NewGuid();
var message = new FakeCommand
{
Int32Value = new Random().Next(),
StringValue = Guid.NewGuid().ToString(),
};
var envelope = new Envelope(messageId, message, correlationId: correlationId);
var serializer = new JsonMessageSerializer();
// Act
var actual = PendingCommand.FromEnvelope(processManager, envelope, serializer);
// Assert
actual.ProcessManagerType.Should().Be(typeof(FakeProcessManager).FullName);
actual.ProcessManagerId.Should().Be(processManager.Id);
actual.MessageId.Should().Be(messageId);
actual.CorrelationId.Should().Be(correlationId);
actual.CommandJson.Should().Be(serializer.Serialize(message));
}