private static IEnumerable <TeachingEvent> MockEvents()
{
var event1 = new TeachingEvent()
{
Name = "Event 1", TypeId = 123
};
var event2 = new TeachingEvent()
{
Name = "Event 2", TypeId = 123
};
var event3 = new TeachingEvent()
{
Name = "Event 3", TypeId = 123
};
var event4 = new TeachingEvent()
{
Name = "Event 4", TypeId = 123
};
var event5 = new TeachingEvent()
{
Name = "Event 5", TypeId = 456
};
return(new[] { event1, event2, event3, event4, event5 });
}
public void CandidateYetToRegisterForTeachingEvent_WhenNotYetRegistered_ReturnsTrue()
{
var candidate = new Candidate()
{
Id = Guid.NewGuid()
};
var teachingEvent = new TeachingEvent()
{
Id = Guid.NewGuid()
};
var entity = new Entity();
entity["msevtmgt_contactid"] = new EntityReference("dfe_candidate", (Guid)candidate.Id);
entity["msevtmgt_eventid"] = new EntityReference("msevtmgt_event", (Guid)teachingEvent.Id);
_mockService.Setup(m => m.CreateQuery("dfe_candidateprivacypolicy", _context))
.Returns(new List <Entity> {
entity
}.AsQueryable());
var result = _crm.CandidateYetToRegisterForTeachingEvent((Guid)candidate.Id, Guid.NewGuid());
result.Should().BeTrue();
}
public void Validate_EventDoesNotAcceptOnlineRegistrations_HasError()
{
var mockTeachingEvent = new TeachingEvent {
Id = Guid.NewGuid(), WebFeedId = null
};
var mockPickListItem = new PickListItem {
Id = 123
};
_mockStore
.Setup(mock => mock.GetTeachingEventAsync((Guid)mockTeachingEvent.Id))
.ReturnsAsync(mockTeachingEvent);
_mockStore
.Setup(mock => mock.GetPickListItems("msevtmgt_eventregistration", "dfe_channelcreation"))
.Returns(new[] { mockPickListItem }.AsQueryable());
var registration = new TeachingEventRegistration()
{
EventId = (Guid)mockTeachingEvent.Id,
ChannelId = mockPickListItem.Id,
};
var result = _validator.TestValidate(registration);
result.IsValid.Should().BeFalse();
result.ShouldHaveValidationErrorFor("EventId")
.WithErrorMessage("Attendence cannot be registered for this event via the API (it has no WebFeedId).");
}
public void Validate_WhenValid_HasNoErrors()
{
var mockTeachingEvent = new TeachingEvent {
Id = Guid.NewGuid(), WebFeedId = "123"
};
var mockPickListItem = new PickListItem {
Id = 123
};
_mockStore
.Setup(mock => mock.GetTeachingEventAsync((Guid)mockTeachingEvent.Id))
.ReturnsAsync(mockTeachingEvent);
_mockStore
.Setup(mock => mock.GetPickListItems("msevtmgt_eventregistration", "dfe_channelcreation"))
.Returns(new[] { mockPickListItem }.AsQueryable());
var registration = new TeachingEventRegistration()
{
EventId = (Guid)mockTeachingEvent.Id,
ChannelId = mockPickListItem.Id,
};
var result = _validator.TestValidate(registration);
result.IsValid.Should().BeTrue();
}
public async Task <IActionResult> Upsert([FromBody] TeachingEvent teachingEvent)
{
var operation = new TeachingEventUpsertOperation(teachingEvent);
var validator = new TeachingEventUpsertOperationValidator(_crm);
var result = validator.Validate(operation);
result.AddToModelState(ModelState, null);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Save independently so that the building gets an Id populated immediately.
// We also persist in the cache so it is immediately available.
if (teachingEvent.Building != null)
{
_crm.Save(teachingEvent.Building);
await _store.SaveAsync(new TeachingEventBuilding[] { teachingEvent.Building });
teachingEvent.BuildingId = teachingEvent.Building.Id;
}
_crm.Save(teachingEvent);
await _store.SaveAsync(new TeachingEvent[] { teachingEvent });
return(CreatedAtAction(
actionName: nameof(Get),
routeValues: new { readableId = teachingEvent.ReadableId },
value: teachingEvent));
}
public async Task Upsert_ValidRequestWithBuilding_SavesInCrmAndCaches()
{
const string testName = "test";
var buildingId = Guid.NewGuid();
var newBuilding = new TeachingEventBuilding()
{
Id = buildingId
};
var newTeachingEvent = new TeachingEvent()
{
Name = testName, Building = newBuilding
};
_mockCrm.Setup(mock => mock.Save(newBuilding)).Verifiable();
_mockCrm.Setup(mock => mock.Save(It.Is <TeachingEvent>(e => e.BuildingId == buildingId))).Verifiable();
_mockStore.Setup(mock => mock.SaveAsync(new TeachingEventBuilding[] { newBuilding })).Verifiable();
_mockStore.Setup(mock => mock.SaveAsync(new TeachingEvent[] { newTeachingEvent })).Verifiable();
var response = await _controller.Upsert(newTeachingEvent);
_mockCrm.Verify();
_mockStore.Verify();
var created = response.Should().BeOfType <CreatedAtActionResult>().Subject;
var teachingEvent = created.Value.Should().BeAssignableTo <TeachingEvent>().Subject;
teachingEvent.Name.Should().Be(testName);
teachingEvent.Building.Should().Be(newBuilding);
}
public void InternalName_Set_ReturnsName()
{
var teachingEvent = new TeachingEvent()
{
Name = "name"
};
teachingEvent.InternalName.Should().Be(teachingEvent.Name);
}
public void Validate_EndAtIsEarlierThanStartAt_HasError()
{
var invalidTeachingEvent = new TeachingEvent
{
StartAt = DateTime.UtcNow.AddDays(2),
EndAt = DateTime.UtcNow.AddDays(1)
};
_validator.ShouldHaveValidationErrorFor(teachingEvent => teachingEvent.EndAt, invalidTeachingEvent);
}
public void Constructor_WithTeachingEvent()
{
var teachingEvent = new TeachingEvent()
{
Id = Guid.NewGuid(), ReadableId = "test-1"
};
var operation = new TeachingEventUpsertOperation(teachingEvent);
operation.Id.Should().Be(teachingEvent.Id);
operation.ReadableId.Should().Be(teachingEvent.ReadableId);
}
public async Task SaveAsync_WithNewModel_Adds()
{
var teachingEvent = new TeachingEvent()
{
Id = Guid.NewGuid(), Name = "TestEvent"
};
await _store.SaveAsync(new TeachingEvent[] { teachingEvent });
DbContext.TeachingEvents
.FirstOrDefault(e => e.Name == teachingEvent.Name)
.Should().NotBeNull();
}
public void IsVirtual_ReturnsCorrectly(bool isOnline, string addressPostcode, bool expected)
{
var teachingEvent = new TeachingEvent()
{
IsOnline = isOnline,
Building = new TeachingEventBuilding()
{
AddressPostcode = addressPostcode
},
};
teachingEvent.IsVirtual.Should().Be(expected);
}
public async Task Upsert_WhenRequestIsInvalid_RepondsWithValidationErrorAsync()
{
const string expectedErrorKey = "Name";
const string expectedErrorMessage = "Name must be specified";
var request = new TeachingEvent();
_controller.ModelState.AddModelError(expectedErrorKey, expectedErrorMessage);
var response = await _controller.Upsert(request);
var badRequest = response.Should().BeOfType <BadRequestObjectResult>().Subject;
var errors = badRequest.Value.Should().BeOfType <SerializableError>().Subject;
errors.Should().ContainKey(expectedErrorKey).WhichValue.Should().BeOfType <string[]>().Which.Should().Contain(expectedErrorMessage);
}
public async void Get_ReturnsTeachingEvent()
{
var teachingEvent = new TeachingEvent()
{
ReadableId = "123"
};
_mockStore.Setup(mock => mock.GetTeachingEventAsync(teachingEvent.ReadableId)).ReturnsAsync(teachingEvent);
var response = await _controller.Get(teachingEvent.ReadableId);
var ok = response.Should().BeOfType <OkObjectResult>().Subject;
ok.Value.Should().Be(teachingEvent);
}
public void IsInPerson_ReturnsCorrectly(bool isOnline, bool isVirtual, bool expected)
{
var teachingEvent = new TeachingEvent()
{
IsOnline = isOnline,
};
if (isVirtual || !isOnline)
{
teachingEvent.Building = new TeachingEventBuilding()
{
AddressPostcode = "KY11 9YU"
};
}
teachingEvent.IsInPerson.Should().Be(expected);
}
public void Validate_WhenValid_HasNoErrors()
{
var client = new TeachingEvent()
{
ReadableId = "Test",
Name = "Test name",
Summary = "Test summary",
Description = "Test description",
ProviderContactEmail = "*****@*****.**",
StartAt = DateTime.UtcNow.AddDays(1),
EndAt = DateTime.UtcNow.AddDays(1),
};
var result = _validator.Validate(client);
result.IsValid.Should().BeTrue();
}
public void Validate_WhenExistingEventWithReadableIdHasDifferentTeachingEventId_HasErrors()
{
var operation = new TeachingEventUpsertOperation()
{
Id = Guid.NewGuid(), ReadableId = "existing"
};
var teachingEvent = new TeachingEvent()
{
Id = Guid.NewGuid()
};
_mockCrm.Setup(m => m.GetTeachingEvent("existing")).Returns(teachingEvent);
var result = _validator.Validate(operation);
result.IsValid.Should().BeFalse();
}
public async Task SaveAsync_WithExistingModel_Updates()
{
var teachingEvent = new TeachingEvent()
{
Id = Guid.NewGuid(), Name = "TestEvent"
};
await _store.SaveAsync(new TeachingEvent[] { teachingEvent });
teachingEvent.Name += "Updated";
await _store.SaveAsync(new TeachingEvent[] { teachingEvent });
var teachingEventNames = DbContext.TeachingEvents.Select(e => e.Name).ToList();
teachingEventNames.ForEach(name => name.Should().Contain("Updated"));
}
public void AddAttendee_ValidRequest_EnqueuesJobRespondsWithNoContent()
{
var teachingEvent = new TeachingEvent()
{
Id = Guid.NewGuid()
};
var request = new TeachingEventAddAttendee()
{
EventId = (Guid)teachingEvent.Id, Email = "*****@*****.**", FirstName = "John", LastName = "Doe"
};
var response = _controller.AddAttendee(request);
response.Should().BeOfType <NoContentResult>();
_mockJobClient.Verify(x => x.Create(
It.Is <Job>(job => job.Type == typeof(UpsertCandidateJob) && job.Method.Name == "Run" &&
IsMatch(request.Candidate, (string)job.Args[0])),
It.IsAny <EnqueuedState>()));
}
public async Task Upsert_WhenReadableIdIsNotUnique_RepondsWithValidationErrorAsync()
{
var existingTeachingEvent = new TeachingEvent()
{
Id = Guid.NewGuid(), ReadableId = "existing"
};
_mockCrm.Setup(m => m.GetTeachingEvent("existing")).Returns(existingTeachingEvent);
var request = new TeachingEvent()
{
ReadableId = "existing"
};
var response = await _controller.Upsert(request);
var badRequest = response.Should().BeOfType <BadRequestObjectResult>().Subject;
var errors = badRequest.Value.Should().BeOfType <SerializableError>().Subject;
errors.Should().ContainKey("ReadableId").WhichValue.Should().BeOfType <string[]>().Which.Should().Contain("Must be unique");
}
private static List <TeachingEvent> MockTeachingEvents()
{
var buildings = MockTeachingEventBuildings();
var sharedBuildingId = buildings[0].Id;
var event1 = new TeachingEvent()
{
Id = Guid.NewGuid(),
ReadableId = "1",
Name = "Event 1",
TypeId = (int)TeachingEvent.EventType.TrainToTeachEvent,
IsOnline = true,
StartAt = DateTime.UtcNow.AddDays(5),
BuildingId = sharedBuildingId
};
var event2 = new TeachingEvent()
{
Id = FindEventGuid,
ReadableId = "2",
Name = "Event 2",
StartAt = DateTime.UtcNow.AddDays(1),
TypeId = (int)TeachingEvent.EventType.ApplicationWorkshop,
BuildingId = buildings[1].Id
};
var event3 = new TeachingEvent()
{
Id = Guid.NewGuid(),
ReadableId = "3",
Name = "Event 3",
StartAt = DateTime.UtcNow.AddDays(10),
TypeId = (int)TeachingEvent.EventType.SchoolOrUniversityEvent,
BuildingId = buildings[2].Id
};
var event4 = new TeachingEvent()
{
Id = Guid.NewGuid(),
ReadableId = "4",
Name = "Event 4",
StartAt = DateTime.UtcNow.AddDays(3),
TypeId = (int)TeachingEvent.EventType.SchoolOrUniversityEvent,
BuildingId = buildings[3].Id
};
var event5 = new TeachingEvent()
{
Id = Guid.NewGuid(),
ReadableId = "5",
Name = "Event 5",
IsOnline = true,
TypeId = (int)TeachingEvent.EventType.OnlineEvent,
StartAt = DateTime.UtcNow.AddDays(15),
};
var event6 = new TeachingEvent()
{
Id = Guid.NewGuid(),
ReadableId = "6",
Name = "Event 6",
StartAt = DateTime.UtcNow.AddDays(60),
TypeId = (int)TeachingEvent.EventType.SchoolOrUniversityEvent,
BuildingId = sharedBuildingId
};
var event7 = new TeachingEvent()
{
Id = Guid.NewGuid(),
ReadableId = "7",
Name = "Event 7",
StartAt = DateTime.UtcNow.AddYears(-1),
TypeId = (int)TeachingEvent.EventType.SchoolOrUniversityEvent,
BuildingId = buildings[4].Id
};
return(new List <TeachingEvent>()
{
event1, event2, event3, event4, event5, event6, event7
});
}
public void InternalTimeZone_Default_ReturnsGmtCode()
{
var teachingEvent = new TeachingEvent();
teachingEvent.InternalTimeZone.Should().Be(85);
}
