public async Task Test_SubtaskSearchQuery_FindByJobId_None_Should_ReturnEmpty()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
var tasks = new SubtaskFaker().SetJob(job).Generate(17);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, job);
await dbContext.Setup(x => x.Tasks, tasks);
var search = new SubtaskSearchCriteria()
{
JobId = Guid.Empty
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new SubtaskSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(0);
results.TotalPages.Should().Be(0);
results.Data.Should().BeNullOrEmpty();
}
public async Task Test_EndJob_Success_True_Should_Be_Completed_With_EndTime()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
var message = new TestEndJobMessage()
{
JobId = job.JobId,
EndTime = DateTimeOffset.Now,
Success = true
};
// act
await _consumer.Consume(new TestConsumeContext <EndJob>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Jobs.SingleOrDefault(j => j.JobId == job.JobId);
actual.Should().NotBeNull();
actual.Status.Should().Be(Status.Completed, because: "job status updated");
actual.EndTime.Should().BeCloseTo(message.EndTime, because: "job end time updated");
}
public async Task Test_StartJob_AlreadyInProgress_Should_noop()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
var message = new TestStartJobMessage
{
JobId = job.JobId,
StartTime = DateTimeOffset.Now.AddDays(99)
};
// act
await _consumer.Consume(new TestConsumeContext <StartJob>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Jobs.SingleOrDefault(j => j.JobId == job.JobId);
actual.Should().NotBeNull();
actual.Status.Should().Be(job.Status);
actual.StartTime.Should().BeCloseTo(job.StartTime.Value, because: "job start time should not have changed");
}
public async Task Test_GetJob_InProgress_Should_ReturnModel()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, job);
// act
var actual = await _service.GetJob(job.JobId);
// assert
actual.Should().NotBeNull();
actual.IsOk().Should().BeTrue();
var model = actual.Payload;
model.JobId.Should().Be(job.JobId);
model.CorrelationId.Should().Be(job.CorrelationId);
model.Type.Should().Be(job.Type);
model.Namespace.Should().Be(job.Namespace);
model.Status.Should().Be(Status.InProgress);
model.StartTime.Should().Be(job.StartTime);
model.EndTime.Should().BeNull();
}
public async Task Test_GetTask_InProgress_Should_ReturnModel()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
var task = new SubtaskFaker().SetJob(job).Generate("default,InProgress");
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, job);
await context.Setup(x => x.Tasks, task);
// act
var actual = await _service.GetTask(task.TaskId);
// assert
actual.Should().NotBeNull();
actual.IsOk().Should().BeTrue();
var model = actual.Payload;
model.TaskId.Should().Be(task.TaskId);
model.Name.Should().Be(task.Name);
model.Status.Should().Be(Status.InProgress);
model.StartTime.Should().BeCloseTo(task.StartTime.Value);
model.EndTime.Should().BeNull();
}
public async Task Test_StartJob_Should_Be_InProgress_With_StartTime()
{
// arrange
var job = new JobFaker().Generate("default,Pending");
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
var message = new TestStartJobMessage
{
JobId = job.JobId,
StartTime = DateTimeOffset.Now
};
// act;
await _consumer.Consume(new TestConsumeContext <StartJob>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Jobs.SingleOrDefault(j => j.JobId == job.JobId);
actual.Should().NotBeNull();
actual.Status.Should().Be(Status.InProgress, because: "job status updated");
actual.StartTime.Should().BeCloseTo(message.StartTime, because: "job start time updated");
}
public async Task Test_CreateTask_Should_SendMessage_And_ReturnOk()
{
// arrange
var job = new JobFaker().Generate("default,Pending");
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, job);
var form = new CreateSubtaskForm()
{
JobId = job.JobId,
TaskId = NewId.NextGuid(),
Name = "test-createtask-ok"
};
_mockSendEndpointProvider
.SetupMessage <CreateSubtask>(new
{
JobId = form.JobId,
TaskId = form.TaskId,
Name = form.Name
});
// act
var result = await _service.CreateTask(form);
// assert
result.Should().NotBeNull();
result.IsOk().Should().BeTrue();
_mocks.Verify();
}
public async Task Test_CreateTask_DuplicateGuid_Should_ReturnConflict()
{
// arrange
var job = new JobFaker().Generate("default,Pending");
var task = new SubtaskFaker().SetJob(job).Generate("default,Pending");
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, job);
await context.Setup(x => x.Tasks, task);
var form = new CreateSubtaskForm()
{
JobId = job.JobId,
TaskId = task.TaskId,
Name = "test-createtask-task-id-already-exists"
};
// act
var result = await _service.CreateTask(form);
// assert
result.Should().NotBeNull();
result.IsConflict().Should().BeTrue();
result.ErrorMessage.Message.Should().StartWith("Sub-task already exists");
}
public async Task Test_StartSubtask_NotFound_Should_noop()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
var task = new SubtaskFaker().SetJob(job).Generate("defaults,Pending");
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
await dbContext.Setup(x => x.Tasks, task);
var message = new TestStartSubtaskMessage
{
TaskId = Guid.NewGuid(), /* task does not exist */
StartTime = DateTimeOffset.Now
};
// act
await _consumer.Consume(new TestConsumeContext <StartSubtask>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Tasks.SingleOrDefault(t => t.TaskId == task.TaskId);
actual.Should().NotBeNull();
actual.Status.Should().Be(task.Status, "task status should not have changed");
actual.StartTime.Should().Be(task.StartTime, because: "task start time should not have changed");
}
public async Task Test_JobSearchQuery_FindByTypeAndNamespace_Should_ReturnMatching()
{
// arrange
var jobs = new JobFaker().Generate(100);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, jobs);
var expected = jobs[39];
var search = new JobSearchCriteria()
{
Type = expected.Type, Namespace = expected.Namespace
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new JobSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(1);
results.TotalPages.Should().Be(1);
results.Data.Should().HaveCount(1);
results.Data.Should().OnlyContain(x => x.Type == expected.Type && x.Namespace == expected.Namespace);
}
public async Task Test_JobSearchQuery_FindByCorrelationId_None_Should_ReturnEmpty()
{
// arrange
var correlationId = Guid.NewGuid();
var bulkJobs = new JobFaker().Generate(100);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, bulkJobs);
var search = new JobSearchCriteria()
{
CorrelationId = correlationId
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new JobSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(0);
results.TotalPages.Should().Be(0);
results.Data.Should().BeNullOrEmpty();
}
public async Task Test_StartJob_Should_SendMessage()
{
// arrange
var job = new JobFaker().Generate("default,Pending");
var startTime = DateTimeOffset.UtcNow;
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, job);
_mockSendEndpointProvider
.SetupMessage <StartJob>(new
{
JobId = job.JobId,
StartTime = startTime
});
// act
var result = await _service.StartJob(job.JobId, startTime);
// assert
result.Should().NotBeNull();
result.IsOk().Should().BeTrue();
_mocks.Verify();
}
public async Task Test_ListJobs_Find_ByCorrelationId_Should_ReturnPagedList()
{
// arrange
var correlationId = Guid.NewGuid();
var bulkJobs = new JobFaker().Generate(100);
var relatedJobs = new JobFaker().SetCorrelationId(correlationId).Generate(10);
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, bulkJobs);
await context.Setup(x => x.Jobs, relatedJobs);
var search = new JobSearchCriteria()
{
CorrelationId = correlationId
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var result = await _service.ListJobs(search, paging);
// assert
result.Should().NotBeNull();
result.IsOk().Should().BeTrue();
var payload = result.Payload;
payload.TotalItems.Should().Be(10);
payload.TotalPages.Should().Be(1);
payload.Data.Should().HaveCount(10);
payload.Data.Should().OnlyContain(x => relatedJobs.Select(j => j.JobId).Contains(x.JobId));
}
public async Task Test_EndJob_Should_SendMessage()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
var endTime = DateTimeOffset.UtcNow;
var isSuccess = true;
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, job);
_mockSendEndpointProvider
.SetupMessage <EndJob>(new
{
JobId = job.JobId,
EndTime = endTime,
Success = isSuccess
});
// act
var result = await _service.EndJob(job.JobId, endTime, isSuccess);
// assert
result.Should().NotBeNull();
result.IsOk().Should().BeTrue();
_mocks.Verify();
}
public async Task Test_SubtaskSearchQuery_TinyPageSize_Should_ReturnPagedResult()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
var tasks = new SubtaskFaker().SetJob(job).Generate(100);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, job);
await dbContext.Setup(x => x.Tasks, tasks);
var search = new SubtaskSearchCriteria();
var paging = new PagingCriteria()
{
Page = 1, Size = 5
};
// act
var results = await new SubtaskSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(5);
results.TotalItems.Should().Be(100);
results.TotalPages.Should().Be(20);
results.Data.Should().HaveCount(5);
}
public async Task Test_ListJobs_FindAll_Should_ReturnPagedList()
{
// arrange
var jobs = new JobFaker()
.Generate(100);
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, jobs);
var search = new JobSearchCriteria()
{
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var result = await _service.ListJobs(search, paging);
// assert
result.Should().NotBeNull();
result.IsOk().Should().BeTrue();
var payload = result.Payload;
payload.TotalItems.Should().Be(100);
payload.TotalPages.Should().Be(4);
payload.Data.Should().HaveCount(25);
}
public async Task Test_CreateSubtask_Empty_TaskId_Should_noop()
{
// arrange
var job = new JobFaker().Generate();
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
var message = new TestCreateSubtaskMessage()
{
JobId = job.JobId,
TaskId = Guid.Empty,
Name = "test-create-subtask-empty-taskid"
};
// act
await _consumer.Consume(new TestConsumeContext <CreateSubtask>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Tasks.ToList();
actual.Should().BeNullOrEmpty("no tasks created without a valid parent job id");
}
public async Task Test_EndSubtask_Success_False_Should_Be_Failed_With_EndTime()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
var task = new SubtaskFaker().SetJob(job).Generate("defaults,InProgress");
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
await dbContext.Setup(x => x.Tasks, task);
var message = new TestEndSubtaskMessage()
{
TaskId = task.TaskId,
EndTime = DateTimeOffset.Now,
Success = false
};
// act
await _consumer.Consume(new TestConsumeContext <EndSubtask>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Tasks.SingleOrDefault(t => t.TaskId == task.TaskId);
actual.Should().NotBeNull();
actual.Status.Should().Be(Status.Failed, because: "task status updated");
actual.EndTime.Should().BeCloseTo(message.EndTime, because: "task end time updated");
}
public async Task Test_CreateSubtask_Should_PersistNewJob()
{
// arrange
var job = new JobFaker().Generate();
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
var message = new TestCreateSubtaskMessage()
{
JobId = job.JobId,
TaskId = NewId.NextGuid(),
Name = "test-create-subtask",
Meta = new Dictionary <string, object>()
{
{ "foo", "bar" },
{ "baz", 1 },
{ "zap", DateTime.UtcNow }
}
};
// act
await _consumer.Consume(new TestConsumeContext <CreateSubtask>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Tasks.SingleOrDefault(t => t.TaskId == message.TaskId);
actual.Should().NotBeNull();
actual.TaskId.Should().Be(message.TaskId);
actual.Name.Should().Be(message.Name);
actual.Meta.Should().BeEquivalentTo(message.Meta);
}
public async Task Test_EndSubtask_AlreadyComplete_Should_noop()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
var task = new SubtaskFaker().SetJob(job).Generate("defaults,Completed");
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
await dbContext.Setup(x => x.Tasks, task);
var message = new TestEndSubtaskMessage()
{
TaskId = task.TaskId,
EndTime = DateTimeOffset.Now.AddDays(99),
Success = true
};
// act
await _consumer.Consume(new TestConsumeContext <EndSubtask>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Jobs.SingleOrDefault(j => j.JobId == job.JobId);
actual.Should().NotBeNull();
actual.Status.Should().Be(job.Status, "task start time should not have changed");
actual.StartTime.Should().BeCloseTo(job.StartTime.Value, because: "task start time should not have changed");
actual.EndTime.Should().BeNull("task end time not set");
}
public async Task Test_SubtaskSearchQuery_DefaultCriteria_Should_ReturnAll()
{
// arrange
var job = new JobFaker().Generate();
var tasks = new SubtaskFaker().SetJob(job).Generate(100);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, job);
await dbContext.Setup(x => x.Tasks, tasks);
var search = new SubtaskSearchCriteria()
{
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new SubtaskSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(100);
results.TotalPages.Should().Be(4);
results.Data.Should().HaveCount(25);
results.Data.Should().OnlyHaveUniqueItems(x => x.TaskId);
}
public async Task Test_JobSearchQuery_FindByCorrelationId_Should_ReturnMatching()
{
// arrange
var correlationId = Guid.NewGuid();
var bulkJobs = new JobFaker().Generate(100);
var relatedJobs = new JobFaker().SetCorrelationId(correlationId).Generate(13);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, bulkJobs);
await dbContext.Setup(x => x.Jobs, relatedJobs);
var search = new JobSearchCriteria()
{
CorrelationId = correlationId
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new JobSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(13);
results.TotalPages.Should().Be(1);
results.Data.Should().HaveCount(13);
results.Data.Should().OnlyContain(x => relatedJobs.Select(j => j.JobId).Contains(x.JobId));
}
public async Task Test_EndJob_NotFound_Should_noop()
{
// arrange
var job = new JobFaker().Generate("default,InProgress");
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
var message = new TestEndJobMessage()
{
JobId = Guid.NewGuid(), /* job does not exist */
EndTime = DateTimeOffset.Now.AddDays(99),
Success = false
};
// act
await _consumer.Consume(new TestConsumeContext <EndJob>(message));
// assert
var actual = DbContextFactory.Instance
.CreateDbContext <PortAuthorityDbContext>()
.Jobs.SingleOrDefault(j => j.JobId == job.JobId);
actual.Should().NotBeNull();
actual.Status.Should().Be(job.Status);
actual.StartTime.Should().BeCloseTo(job.StartTime.Value, because: "job start time should not have changed");
actual.EndTime.Should().BeNull("bad job id, end time not set");
}
public async Task Test_FindJob_ByGuid_Should_Match()
{
// arrange
var jobs = new JobFaker().Generate(10);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, jobs);
// act
var expected = jobs[3]; /* random selection by fair dice roll */
var actual = dbContext.Jobs.FirstOrDefault(x => x.JobId == expected.JobId);
// assert
actual.Should().NotBeNull();
actual.Should().BeEquivalentTo(expected);
}
public async Task Test_CreateSubtaskConsumer_Should_ConsumeMessage_And_CreateJob()
{
// arrange
var consumerHarness = Consumer <CreateSubtaskConsumer>();
var job = new JobFaker().Generate("default,InProgress");
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, job);
var message = new TestCreateSubtaskMessage()
{
JobId = job.JobId,
TaskId = NewId.NextGuid(),
Name = "test-create-subtask",
Meta = new Dictionary <string, object>()
{
{ "foo", "bar" },
{ "baz", 1 },
{ "zap", DateTime.UtcNow }
}
};
await Harness.Start();
try
{
// act
await Harness.InputQueueSendEndpoint.Send <CreateSubtask>(message);
// assert
Assert.That(await Harness.Consumed.Any <CreateSubtask>(), "endpoint consumed message");
Assert.That(await consumerHarness.Consumed.Any <CreateSubtask>(), "actual consumer consumed the message");
Assert.That(await Harness.Published.Any <Fault <CreateSubtask> >(), Is.False, "message handled without fault");
var actual = GetDbContext().Tasks.SingleOrDefault(t => t.TaskId == message.TaskId);
actual.Should().NotBeNull();
actual.TaskId.Should().Be(message.TaskId);
actual.Name.Should().Be(message.Name);
actual.Meta.Should().BeEquivalentTo(message.Meta);
}
finally
{
await Harness.Stop();
}
}
public async Task Test_AddJob_Should_Persist()
{
// arrange
var job = new JobFaker().Generate();
// act
await using var dbContext = GetDbContext();
await dbContext.Jobs.AddAsync(job);
await dbContext.SaveChangesAsync();
// assert
await using var actualDbContext = GetDbContext();
var actual = actualDbContext.Jobs.Find(job.Id);
actual.Should().BeEquivalentTo(job);
}
public async Task Test_EndSubtaskConsumer_Success_True_Should_Consume_With_Status_Completed()
{
// arrange
var consumerHarness = Consumer <EndSubtaskConsumer>();
var job = new JobFaker().Generate("default,InProgress");
var task = new SubtaskFaker().SetJob(job).Generate("default,InProgress");
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, job);
await dbContext.Setup(x => x.Tasks, task);
var message = new TestEndSubtaskMessage()
{
TaskId = task.TaskId,
EndTime = DateTimeOffset.Now,
Success = true
};
await Harness.Start();
try
{
// act
await Harness.InputQueueSendEndpoint.Send <EndSubtask>(message);
// assert
Assert.That(await Harness.Consumed.Any <EndSubtask>(), "endpoint consumed message");
Assert.That(await consumerHarness.Consumed.Any <EndSubtask>(), "actual consumer consumed the message");
Assert.That(await Harness.Published.Any <Fault <EndSubtask> >(), Is.False, "message handled without fault");
await using var actualDbContext = GetDbContext();
var actual = actualDbContext.Tasks.SingleOrDefault(t => t.TaskId == task.TaskId);
actual.Should().NotBeNull();
actual.TaskId.Should().Be(task.TaskId);
actual.Status.Should().Be(Status.Completed, "task status is successful");
actual.EndTime.Should().BeCloseTo(message.EndTime, because: "task end time updated");
}
finally
{
await Harness.Stop();
}
}
public async Task Test_StartJobConsumer_Should_Consume_With_Status_ImProgress()
{
// arrange
var consumerHarness = Consumer <StartJobConsumer>();
var job = new JobFaker().Generate("default,Pending");
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, new [] { job });
var message = new TestStartJobMessage()
{
JobId = job.JobId,
StartTime = DateTimeOffset.Now
};
await Harness.Start();
try
{
// act
await Harness.InputQueueSendEndpoint.Send <StartJob>(message);
// assert
Assert.That(await Harness.Consumed.Any <StartJob>(), "endpoint consumed message");
Assert.That(await consumerHarness.Consumed.Any <StartJob>(), "actual consumer consumed the message");
Assert.That(await Harness.Published.Any <Fault <StartJob> >(), Is.False, "message handled without fault");
await using var actualDbContext = GetDbContext();
var actual = actualDbContext.Jobs.SingleOrDefault(j => j.JobId == message.JobId);
actual.Should().NotBeNull();
actual.JobId.Should().Be(message.JobId);
actual.Status.Should().Be(Status.InProgress, "job status updated");
actual.StartTime.Should().BeCloseTo(message.StartTime, because: "job start time updated");
}
finally
{
await Harness.Stop();
}
}
public async Task Test_CreateSubtask_Invalid_ParentJobId_Should_Throw_InvalidOperationException()
{
// arrange
var job = new JobFaker().Generate();
await using var dbContext = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await dbContext.Setup(x => x.Jobs, job);
var message = new TestCreateSubtaskMessage()
{
JobId = Guid.NewGuid(),
TaskId = NewId.NextGuid(),
Name = "test-create-subtask-invalid-jobid"
};
// act
Func <Task> act = async() => { await _consumer.Consume(new TestConsumeContext <CreateSubtask>(message)); };
// assert
await act.Should().ThrowAsync <InvalidOperationException>();
}
public async Task Test_UpdateJob_Should_Persist()
{
// arrange
var job = new JobFaker().Generate("default,Pending");
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, job);
// act
var updated = dbContext.Jobs.Find(job.Id);
updated.Status = Status.InProgress;
updated.StartTime = DateTimeOffset.Now;
await dbContext.SaveChangesAsync();
// assert
await using var actualDbContext = GetDbContext();
var actual = actualDbContext.Jobs.Find(job.Id);
actual.Should().BeEquivalentTo(updated);
}
