public void GivenTheUserDoesWantToReceiveEmails()
{
var response = ApiCaller.Delete <ActionReponse <UserModel> >(
Routes.GetDoNotEmailUser(ScenarioCache.GetUserId()));
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
public void WhenTheBlockIsDeleted()
{
var blockId = ScenarioCache.GetId(ModelIdKeys.BlockId);
var response = ApiCaller.Delete <ActionReponse <BlockModel> >(Routes.GetById(Routes.Blocks, blockId));
ScenarioCache.StoreActionResponse(response);
}
public void WhenTheClassIsUpdated()
{
var response = ApiCaller.Put <ActionReponse <ClassModel> >(ScenarioCache.Get <ClassModel>(ModelKeys.Class),
Routes.GetById(Routes.Classes, ScenarioCache.GetId(ModelIdKeys.ClassId)));
ScenarioCache.StoreActionResponse(response);
}
public void WhenTheUserTriesToEnrolInTheBlock()
{
var response = ApiCaller.Post <ActionReponse <UserModel> >(new EnrolmentModel(ScenarioCache.GetId(ModelIdKeys.BlockId)),
Routes.GetEnrolUserInBlock(ScenarioCache.GetUserId()));
ScenarioCache.StoreActionResponse(response);
}
public void ThenTheUserDoesntHaveAPass()
{
var response = ApiCaller.Get <List <PassModel> >(Routes.GetUserPasses(ScenarioCache.GetId(ModelIdKeys.UserId)));
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsEmpty(response.Data);
}
public void WhenTheStandAloneEventIsAttemptedToBeCreated()
{
var response = ApiCaller.Post <ActionReponse <StandAloneEventModel> >(ScenarioCache.Get <StandAloneEventModel>(ModelKeys.StandAloneEvent), Routes.StandAloneEvent);
ScenarioCache.StoreActionResponse(response);
ScenarioCache.Store(ModelIdKeys.StandAloneEventId, response.Data.ActionResult.Id);
}
public void ThenTheUserSScheduleIsNotEmtpy()
{
var response = ScenarioCache.Get <RestResponse <List <EventModel> > >(ScheduleResponseKey);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotEmpty(response.Data);
}
public void GivenAValidTeacherAvailabilityIsReadyToBeSubmitted()
{
var availability = new TimeSlotModel(IsoDayOfWeek.Monday, new LocalTimeModel(10, 0), new LocalTimeModel(22, 30));
var teacherAvailability = new TeacherAvailabilityModel(availability.PutIntoList());
ScenarioCache.Store(ModelKeys.TeacherAvailability, teacherAvailability);
}
public void WhenTheCurrentUserIsRetrieved()
{
var response = ApiCaller.Get <UserModel>(Routes.GetCurrentUser);
ScenarioCache.Store(ExpectedUserKey, response.Data);
ScenarioCache.Store(ModelIdKeys.UserId, response.Data.Id);
}
public void ThenTheStudentIsMarkedAgainstTheEvent()
{
var response = ApiCaller.Get <StandAloneEventModel>(Routes.GetById(Routes.StandAloneEvent, ScenarioCache.GetId(ModelIdKeys.StandAloneEventId)));
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.Contains(ScenarioCache.GetId(ModelIdKeys.UserId), response.Data.ActualStudents.Select(x => x.Id).ToList());
}
public void WhenUserIsAttemptedToBeSetUpAsATeacher()
{
var userId = ScenarioCache.GetUserId();
var response = ApiCaller.Post <ActionReponse <TeacherModel> >(Routes.GetTeacherById(userId));
ScenarioCache.StoreActionResponse(response);
}
public void WhenTheBlockRoomUnassignmentIsRequested()
{
var blockId = ScenarioCache.GetId(ModelIdKeys.BlockId);
var response = ApiCaller.Delete <ActionReponse <BlockModel> >(Routes.GetBlockRoom(blockId));
ScenarioCache.StoreActionResponse(response);
}
public static void SetupSystem()
{
ResetDatabase();
ScenarioCache.Store(ModelIdKeys.UserId, 1);
ScenarioCache.Store(ModelIdKeys.StudentIds, new List <int>());
ScenarioCache.Store(ModelIdKeys.BlockIds, new List <int>());
}
public void WhenTheClassRoomUnassignmentIsRequested()
{
var classId = ScenarioCache.GetId(ModelIdKeys.ClassId);
var response = ApiCaller.Delete <ActionReponse <ClassModel> >(Routes.GetClassRoom(classId));
ScenarioCache.StoreActionResponse(response);
}
public void WhenThePassTemplateIsAttemptedToBeCreated()
{
var response = ApiCaller.Post <ActionReponse <PassTemplateModel> >(ScenarioCache.Get <PassTemplateModel>(ModelKeys.PassTemplate), Routes.PassTemplate);
ScenarioCache.StoreActionResponse(response);
ScenarioCache.Store(ModelIdKeys.PassTemplateId, response.Data.ActionResult.Id);
}
public void WhenTheRoomIsAttemptedToBeCreated()
{
var response = ApiCaller.Post <ActionReponse <RoomModel> >(ScenarioCache.Get <RoomModel>(ModelKeys.Room), Routes.Room);
ScenarioCache.StoreActionResponse(response);
ScenarioCache.Store(ModelIdKeys.RoomId, response.Data.ActionResult.Id);
}
public void ThenTheStudentIsMarkedAgainstClass()
{
var response = ApiCaller.Get <List <UserModel> >(Routes.GetClassAttendance(ScenarioCache.GetId(ModelIdKeys.ClassId)));
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.Contains(ScenarioCache.GetId(ModelIdKeys.UserId), response.Data.Select(x => x.Id).ToList());
}
private static void RequestReport(string url)
{
var response = ApiCaller.Get <PassSalesResponse>(url);
ScenarioCache.StoreResponse(response);
ScenarioCache.Store(ModelKeys.PassSalesReport, response.Data);
}
private TeacherModel CreateNewTeacher()
{
new CommonTeacherSteps().GivenAnExistingUserIsATeacher();
var id = ScenarioCache.GetTeacherId();
return(new TeacherModel(id));
}
public void ThenTheirClaimsAre(List <string> expectedClaims)
{
var response = ScenarioCache.Get <RestResponse <List <string> > >(ClaimsResponseKey);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsTrue(expectedClaims.Select(x => x.ToLower()).HasSameItems(response.Data.Select(x => x.ToLower())));
}
public void WhenTheBlockIsUpdated()
{
var response = ApiCaller.Put <ActionReponse <BlockModel> >(ScenarioCache.Get <BlockModel>(ModelKeys.Block),
Routes.GetById(Routes.Blocks, ScenarioCache.GetId(ModelIdKeys.BlockId)));
ScenarioCache.StoreActionResponse(response);
}
public void ThenTheBlockClassCapacityIs(int classCapacity)
{
var block = ApiCaller.Get <BlockModel>(Routes.GetById(Routes.Blocks, ScenarioCache.GetId(ModelIdKeys.BlockId))).Data;
Assert.AreEqual(classCapacity, block.ClassCapacity);
ScenarioCache.Store(ModelKeys.Block, block);
}
public void ThenTheBlockIsNotInviteOnly()
{
var response = ApiCaller.Get <BlockModel>(Routes.GetById(Routes.Blocks, ScenarioCache.GetId(ModelIdKeys.BlockId)));
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsFalse(response.Data.IsInviteOnly);
}
public void ThenBlockCanBeRetrieved()
{
var response = ApiCaller.Get <BlockModel>(Routes.GetById(Routes.Blocks, ScenarioCache.GetId(ModelIdKeys.BlockId)));
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Data);
}
public void GivenAnInvalidTeacherRatesAreReadyToBeSubmitted()
{
var teacherRateSingle = new SettingItemModel(SettingTypes.TeacherRateSolo.ToString().ToLower(), "invalid");
var teacherRateMultiple = new SettingItemModel(SettingTypes.TeacherRatePartnered.ToString().ToLower(), "invalid");
var completeSettings = new CompleteSettingsModel(teacherRateSingle, teacherRateMultiple);
ScenarioCache.Store(ModelKeys.CompleteSettings, completeSettings);
}
public void GivenTheNumberOfClassesInTheBlockIs(int numberOfClasses)
{
var block = ScenarioCache.Get <BlockModel>(ModelKeys.Block);
block.NumberOfClasses = numberOfClasses;
ScenarioCache.Store(ModelKeys.Block, block);
}
public void GivenTheBlockClassCapacityIs(int classCapacity)
{
var block = ScenarioCache.Get <BlockModel>(ModelKeys.Block);
block.ClassCapacity = classCapacity;
ScenarioCache.Store(ModelKeys.Block, block);
}
public void GivenTheBlockIsInviteOnly()
{
var block = ScenarioCache.Get <BlockModel>(ModelKeys.Block);
block.IsInviteOnly = true;
ScenarioCache.Store(ModelKeys.Block, block);
}
public void ThenTheBlockDetailsHasTheRoom()
{
var block = ApiCaller.Get <BlockModel>(Routes.GetById(Routes.Blocks, ScenarioCache.GetId(ModelIdKeys.BlockId))).Data;
var roomId = ScenarioCache.GetId(ModelIdKeys.RoomId);
Assert.IsNotNull(block.Room);
Assert.AreEqual(roomId, block.Room.Id);
}
public void WhenTheCurrentUserChangesTheirName()
{
var usernames = ScenarioCache.Get <UserNamesModel>(ModelKeys.UserNames);
var response = ApiCaller.Put <ActionReponse <ActionReponse <UserModel> > >(usernames, Routes.CurrentUserNames);
ScenarioCache.StoreActionResponse(response);
}
