public async Task DeleteShouldReturnOk()
{
string userId = "Jack";
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim("userId", userId)
}, "mock"));
int newsId = 101;
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.DeleteReminder(userId, newsId)).Returns(Task.FromResult(true));
var controller = new ReminderController(mockService.Object);
controller.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext {
User = user
}
};
var actual = await controller.Delete(newsId);
var actionResult = Assert.IsType <OkObjectResult>(actual);
Assert.True(Convert.ToBoolean(actionResult.Value));
}
public ReminderPage()
{
InitializeComponent();
List <ReminderModel> data1 = ReminderController.InstanceCreation().GetRemindersData();
ReminderList.ItemsSource = data1;
}
public void WhenOverdueListInvalidUser_ThenThrows()
{
ReminderController controller = GetTestableReminderController();
controller.HttpContext.Request.SetAjaxRequest();
controller.HttpContext.Request.SetJsonRequest();
MockHandlerFor(
() => new Mock <GetOverdueRemindersForUser>(null, null),
x => x
.Setup(h => h.Execute(_defaultUser.UserId))
.Throws(new BusinessServicesException("Unable to get overdue reminders.")));
MockHandlerFor(
() => new Mock <GetVehicleById>(null),
x => x
.Setup(h => h.Execute(_defaultUser.UserId, defaultVehicleId))
.Returns(new VehicleModel(
new Vehicle {
VehicleId = defaultVehicleId, Name = "Vehicle"
},
new VehicleStatisticsModel())));
Assert.Throws <BusinessServicesException>(() => { controller.OverdueList(); });
}
public async Task GetShouldReturnOk()
{
string userId = "Jack";
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim("userId", userId)
}, "mock"));
List <ReminderSchedule> reminder = new List <ReminderSchedule>
{
new ReminderSchedule
{
NewsId = 101, Schedule = DateTime.Now.AddDays(2)
}
};
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.GetReminders(userId)).Returns(Task.FromResult(reminder));
var controller = new ReminderController(mockService.Object);
controller.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext {
User = user
}
};
var actual = await controller.Get();
var actionResult = Assert.IsType <OkObjectResult>(actual);
Assert.IsAssignableFrom <List <ReminderSchedule> >(actionResult.Value);
}
public async Task DeleteShouldReturnNotFound()
{
string userId = "Jack";
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim("userId", userId)
}, "mock"));
int newsId = 101;
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.DeleteReminder(userId, newsId)).Throws(new NoReminderFoundException("No reminder found for this news"));
var controller = new ReminderController(mockService.Object);
controller.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext {
User = user
}
};
var actual = await controller.Delete(newsId);
var actionResult = Assert.IsType <NotFoundObjectResult>(actual);
Assert.Equal("No reminder found for this news", actionResult.Value);
}
public async Task PutShouldReturnNotFound()
{
string userId = "Jack";
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim("userId", userId)
}, "mock"));
ReminderSchedule reminder = new ReminderSchedule {
NewsId = 102, Schedule = DateTime.Now.AddDays(2)
};
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.UpdateReminder(userId, reminder)).Throws(new NoReminderFoundException("No reminder found for this news"));
var controller = new ReminderController(mockService.Object);
controller.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext {
User = user
}
};
var actual = await controller.Put(reminder);
var actionResult = Assert.IsType <NotFoundObjectResult>(actual);
Assert.Equal("No reminder found for this news", actionResult.Value);
}
public async Task PostShouldReturnCreated()
{
Reminder reminder = new Reminder
{
UserId = "Jack",
Email = "*****@*****.**",
NewsReminders = new List <ReminderSchedule>
{
new ReminderSchedule
{
NewsId = 102, Schedule = DateTime.Now.AddDays(2)
}
}
};
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.CreateReminder(reminder.UserId, reminder.Email, reminder.NewsReminders[0])).Returns(Task.FromResult(true));
var controller = new ReminderController(mockService.Object);
var actual = await controller.Post(reminder);
var actionresult = Assert.IsType <CreatedResult>(actual);
Assert.True(Convert.ToBoolean(actionresult.Value));
}
public void WhenListReminderGetWithValidVehicleId_ThenReturnsView()
{
var vehicle = new VehicleModel(new Vehicle {
VehicleId = defaultVehicleId
},
new VehicleStatisticsModel());
var reminders = new[]
{
new Reminder {
ReminderId = 1
},
new Reminder {
ReminderId = 2
}
};
MockHandlerFor <GetAllRemindersForVehicle>(
x => x
.Setup(h => h.Execute(defaultVehicleId))
.Returns(reminders));
MockHandlerFor <GetVehicleById>(
x => x
.Setup(h => h.Execute(_defaultUser.UserId, defaultVehicleId))
.Returns(vehicle));
ReminderController controller = GetTestableReminderController();
ActionResult result = controller.List(defaultVehicleId);
var model = result.Extract <List <ReminderListViewModel> >();
Assert.Equal(reminders.Length, model[0].Reminders.Count());
Assert.Equal(reminders[0].ReminderId, model[0].Reminders.First().ReminderId);
}
public void WhenOverdueList_ThenReturnsModel()
{
ReminderController controller = GetTestableReminderController();
controller.HttpContext.Request.SetAjaxRequest();
controller.HttpContext.Request.SetJsonRequest();
var dueDate = new DateTime(2010, 12, 1, 0, 0, 0, DateTimeKind.Utc);
var reminders = new[]
{
new ReminderModel
{
ReminderId = 1,
VehicleId = defaultVehicleId,
Title = "Reminder1",
DueDate = dueDate
},
new ReminderModel
{
ReminderId = 2,
VehicleId = defaultVehicleId,
Title = "Reminder2",
DueDistance = 1000
},
new ReminderModel
{
ReminderId = 3,
VehicleId = defaultVehicleId,
Title = "Reminder3",
DueDate = dueDate,
DueDistance = 1000
},
};
MockHandlerFor(
() => new Mock <GetOverdueRemindersForUser>(null, null),
x => x
.Setup(h => h.Execute(_defaultUser.UserId))
.Returns(reminders));
MockHandlerFor(
() => new Mock <GetVehicleById>(null),
x => x
.Setup(h => h.Execute(_defaultUser.UserId, defaultVehicleId))
.Returns(new VehicleModel(
new Vehicle {
VehicleId = defaultVehicleId, Name = "Vehicle"
},
new VehicleStatisticsModel())));
var result = (JsonResult)controller.OverdueList();
var model = (JsonRemindersOverdueListViewModel)result.Data;
var list = new List <OverdueReminderViewModel>(model.Reminders);
Assert.Equal(reminders.Length, model.Reminders.Count());
Assert.Equal("Reminder1 | Vehicle @ 12/1/2010", list[0].FullTitle);
Assert.Equal("Reminder2 | Vehicle @ 1000", list[1].FullTitle);
Assert.Equal("Reminder3 | Vehicle @ 12/1/2010 or 1000", list[2].FullTitle);
}
public void WhenOverdueListWhenNoReminders_ThenReturnsModelWithEmptyCollection()
{
ReminderController controller = GetTestableReminderController();
controller.HttpContext.Request.SetAjaxRequest();
controller.HttpContext.Request.SetJsonRequest();
MockHandlerFor <GetOverdueRemindersForUser>(
x => x
.Setup(h => h.Execute(_defaultUser.UserId))
.Returns(new ReminderModel[] { }));
MockHandlerFor <GetVehicleById>(
x => x
.Setup(h => h.Execute(_defaultUser.UserId, defaultVehicleId))
.Returns(new VehicleModel(
new Vehicle {
VehicleId = defaultVehicleId, Name = "Vehicle"
},
new VehicleStatisticsModel())));
var result = (JsonResult)controller.OverdueList();
var model = (JsonRemindersOverdueListViewModel)result.Data;
var list = new List <OverdueReminderViewModel>(model.Reminders);
Assert.Equal(0, list.Count());
}
public void WhenDeletingReminder_ThenReturnsToDashboardPage()
{
const int reminderId = 123;
var reminder = new Reminder
{
ReminderId = reminderId,
Title = "TestReminder",
DueDate = DateTime.UtcNow,
DueDistance = 5
};
MockHandlerFor(
() => new Mock <GetReminder>(null),
x => x
.Setup(h => h.Execute(reminderId))
.Returns(reminder));
MockHandlerFor(
() => new Mock <DeleteReminder>(null),
x => x
.Setup(h => h.Execute(_defaultUser.UserId, reminderId)));
ReminderController controller = GetTestableReminderController();
var result = (RedirectToRouteResult)controller.Delete(reminder.ReminderId);
Assert.NotNull(result);
Assert.Equal("List", result.RouteValues["action"]);
Assert.Equal("Reminder", result.RouteValues["controller"]);
}
public void WhenDeletingReminder_ThenRepositoryDeleteCalled()
{
const int reminderId = 123;
var reminder = new Reminder
{
ReminderId = reminderId,
Title = "TestReminder",
DueDate = DateTime.UtcNow,
DueDistance = 5
};
MockHandlerFor(
() => new Mock <GetReminder>(null),
x => x
.Setup(h => h.Execute(reminderId))
.Returns(reminder));
Mock <DeleteReminder> handler = MockHandlerFor(
() => new Mock <DeleteReminder>(null),
x => x
.Setup(h => h.Execute(_defaultUser.UserId, reminderId))
.Verifiable("delete handler not called"));
ReminderController controller = GetTestableReminderController();
controller.Delete(reminder.ReminderId);
handler.Verify();
}
public async Task PostShouldReturnConflict()
{
Reminder reminder = new Reminder
{
UserId = "Jack",
Email = "*****@*****.**",
NewsReminders = new List <ReminderSchedule>
{
new ReminderSchedule
{
NewsId = 101, Schedule = DateTime.Now.AddDays(2)
}
}
};
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.CreateReminder(reminder.UserId, reminder.Email, reminder.NewsReminders[0])).Throws(new ReminderAlreadyExistsException($"This News already have a reminder"));
var controller = new ReminderController(mockService.Object);
var actual = await controller.Post(reminder);
var actionResult = Assert.IsType <ConflictObjectResult>(actual);
Assert.Equal($"This News already have a reminder", actionResult.Value);
}
public async Task PutShouldReturnOk()
{
string userId = "Jack";
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim("userId", userId)
}, "mock"));
ReminderSchedule reminder = new ReminderSchedule {
NewsId = 101, Schedule = DateTime.Now.AddDays(2)
};
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.UpdateReminder(userId, reminder)).Returns(Task.FromResult(true));
var controller = new ReminderController(mockService.Object);
controller.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext {
User = user
}
};
var actual = await controller.Put(reminder);
var actionresult = Assert.IsType <OkObjectResult>(actual);
Assert.True(Convert.ToBoolean(actionresult.Value));
}
public void WhenAddReminderPostWithNullReminder_ThenReturnsToCreatePage()
{
MockDefaultHandlers();
ReminderController controller = GetTestableReminderController();
ActionResult result = controller.Add(defaultVehicleId, null);
Assert.IsType(typeof(ViewResult), result);
}
public void WhenAddReminderGetWithValidVehicleId_ThenReturnsView()
{
MockDefaultHandlers();
ReminderController controller = GetTestableReminderController();
ActionResult result = controller.Add(defaultVehicleId);
Assert.IsType <ViewResult>(result);
}
private ReminderController GetTestableReminderController()
{
var controller = new ReminderController(_mockUserServices.Object, _serviceLocator.Object);
controller.SetFakeControllerContext();
controller.SetUserIdentity(new MileageStatsIdentity(_defaultUser.AuthorizationId,
_defaultUser.DisplayName,
_defaultUser.UserId));
return(controller);
}
public async Task GetShouldReturnNotFound()
{
string userId = "Jack";
var mockService = new Mock<IReminderService>();
mockService.Setup(svc => svc.GetReminders(userId)).Throws(new NoReminderFoundException("No reminders found for this user"));
var controller = new ReminderController(mockService.Object);
var actual = await controller.Get(userId);
var actionResult = Assert.IsType<NotFoundObjectResult>(actual);
Assert.Equal("No reminders found for this user", actionResult.Value);
}
public void WhenOverdueListWithNonJsonCall_ThenReturnsEmpty()
{
ReminderController controller = GetTestableReminderController();
controller.HttpContext.Request.SetAjaxRequest();
// no json set on context
var dueDate = new DateTime(2010, 12, 1, 0, 0, 0, DateTimeKind.Utc);
var reminders = new[]
{
new ReminderModel
{
ReminderId = 1,
VehicleId = defaultVehicleId,
Title = "Reminder1",
DueDate = dueDate
},
new ReminderModel
{
ReminderId = 2,
VehicleId = defaultVehicleId,
Title = "Reminder2",
DueDistance = 1000
},
new ReminderModel
{
ReminderId = 3,
VehicleId = defaultVehicleId,
Title = "Reminder3",
DueDate = dueDate,
DueDistance = 1000
},
};
MockHandlerFor(
() => new Mock <GetOverdueRemindersForUser>(null, null),
x => x
.Setup(h => h.Execute(_defaultUser.UserId))
.Returns(reminders));
MockHandlerFor(
() => new Mock <GetVehicleById>(null),
x => x
.Setup(h => h.Execute(_defaultUser.UserId, defaultVehicleId))
.Returns(new VehicleModel(
new Vehicle {
VehicleId = defaultVehicleId, Name = "Vehicle"
},
new VehicleStatisticsModel())));
ActionResult result = controller.OverdueList();
Assert.IsType <EmptyResult>(result);
}
public void WhenAddReminderPostWithNullReminder_ThenReturnsToCreatePage()
{
MockDefaultHandlers();
ReminderController controller = GetTestableReminderController();
ActionResult result = controller.Add(defaultVehicleId, null);
Assert.IsType(typeof(ContentTypeAwareResult), result);
Assert.Equal(MileageStats.Web.Properties.Messages.PleaseFixInvalidData, controller.TempData["alert"]);
}
public async Task DeleteShouldReturnOk()
{
string userId = "Jack";
int newsId = 101;
var mockService = new Mock<IReminderService>();
mockService.Setup(svc => svc.DeleteReminder(userId, newsId)).Returns(Task.FromResult(true));
var controller = new ReminderController(mockService.Object);
var actual = await controller.Delete(userId, newsId);
var actionResult = Assert.IsType<OkObjectResult>(actual);
Assert.True(Convert.ToBoolean(actionResult.Value));
}
public async Task PutShouldReturnOk()
{
string userId = "Jack";
ReminderSchedule reminder = new ReminderSchedule { NewsId = 101, Schedule = DateTime.Now.AddDays(2) };
var mockService = new Mock<IReminderService>();
mockService.Setup(svc => svc.UpdateReminder(userId, reminder)).Returns(Task.FromResult(true));
var controller = new ReminderController(mockService.Object);
var actual = await controller.Put(userId, reminder);
var actionresult = Assert.IsType<OkObjectResult>(actual);
Assert.True(Convert.ToBoolean(actionresult.Value));
}
public async Task PutShouldReturnNotFound()
{
string userId = "Jack";
ReminderSchedule reminder = new ReminderSchedule { NewsId = 102, Schedule = DateTime.Now.AddDays(2) };
var mockService = new Mock<IReminderService>();
mockService.Setup(svc => svc.UpdateReminder(userId, reminder)).Throws(new NoReminderFoundException("No reminder found for this news"));
var controller = new ReminderController(mockService.Object);
var actual = await controller.Put(userId, reminder);
var actionResult = Assert.IsType<NotFoundObjectResult>(actual);
Assert.Equal("No reminder found for this news", actionResult.Value);
}
public async Task GetShouldReturnNotFound()
{
int newsId = 102;
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.GetReminderByNewsId(newsId)).Throws(new ReminderNotFoundException($"No reminder found for news: {newsId}"));
var controller = new ReminderController(mockService.Object);
var actual = await Assert.ThrowsAsync <ReminderNotFoundException>(() => controller.Get(newsId));
Assert.Equal($"No reminder found for news: {newsId}", actual.Message);
}
public async Task DeleteShouldReturnNotFound()
{
int reminderId = 3;
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.RemoveReminder(reminderId)).Throws(new ReminderNotFoundException($"No reminder found with id: {reminderId}"));
var controller = new ReminderController(mockService.Object);
var actual = await Assert.ThrowsAsync <ReminderNotFoundException>(() => controller.Delete(reminderId));
Assert.Equal($"No reminder found with id: {reminderId}", actual.Message);
}
public void GetShouldReturnAList()
{
var mockService = new Mock <IReminderService>();
mockService.Setup(service => service.GetAllReminders()).Returns(this.GetReminders());
var controller = new ReminderController(mockService.Object);
var actual = controller.Get();
var actionReult = Assert.IsType <OkObjectResult>(actual);
Assert.IsAssignableFrom <List <Reminder> >(actionReult.Value);
}
public void WhenAddReminderPostWithInvalidReminder_ThenReturnsToCreatePage()
{
MockDefaultHandlers();
ReminderController controller = GetTestableReminderController();
controller.ModelState.AddModelError("test", "test error");
var reminderForm = new ReminderFormModel();
ActionResult result = controller.Add(defaultVehicleId, reminderForm);
Assert.IsType(typeof(ContentTypeAwareResult), result);
}
public async Task GetShouldReturnNotFound()
{
int newsId = 102;
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.GetReminderByNewsId(newsId)).Throws(new ReminderNotFoundException($"No reminder found for news: {newsId}"));
var controller = new ReminderController(mockService.Object);
var actual = await controller.Get(newsId);
var actionResult = Assert.IsType <NotFoundObjectResult>(actual);
Assert.Equal($"No reminder found for news: {newsId}", actionResult.Value);
}
public async Task DeleteShouldReturnNotFound()
{
int reminderId = 3;
var mockService = new Mock <IReminderService>();
mockService.Setup(svc => svc.RemoveReminder(reminderId)).Throws(new ReminderNotFoundException($"No reminder found with id: {reminderId}"));
var controller = new ReminderController(mockService.Object);
var actual = await controller.Delete(reminderId);
var actionResult = Assert.IsType <NotFoundObjectResult>(actual);
Assert.Equal($"No reminder found with id: {reminderId}", actionResult.Value);
}
public async Task PostShouldReturnConflict()
{
var mockService = new Mock <IReminderService>();
Reminder reminder = new Reminder {
NewsId = 101, Schedule = DateTime.Now.AddDays(1)
};
mockService.Setup(svc => svc.AddReminder(reminder)).Throws(new ReminderAlreadyExistsException($"This news: {reminder.NewsId} already have a reminder"));
var controller = new ReminderController(mockService.Object);
var actual = await Assert.ThrowsAsync <ReminderAlreadyExistsException>(() => controller.Post(reminder));
Assert.Equal($"This news: {reminder.NewsId} already have a reminder", actual.Message);
}
private void setStrikerDefenderControllers(GameObject ui)
{
//Debug.Log(role);
GetComponent<PlayerInfo>().setHealthController(ui.transform.GetChild(0).GetChild(0).GetComponent<HealthController>());
skillPanel = ui.transform.GetChild(1);
skillPanel.GetChild(0).GetComponent<SkillController>().setPlayerController(this);
skillPanel.GetChild(0).GetComponent<Image>().sprite = role == PlayerRole.Striker ? skillIcons[0] : skillIcons[2];
skillPanel.GetChild(1).GetComponent<SkillController>().setPlayerController(this);
skillPanel.GetChild(1).GetComponent<Image>().sprite = role == PlayerRole.Striker ? skillIcons[1] : skillIcons[3];
Transform supportCrystalPanel = ui.transform.GetChild(2);
mainCrystalController = supportCrystalPanel.GetComponent<MainCrystalController>();
mainCrystalController.SetPlayerController(this);
GameObject ulticrystalObject = ui.transform.GetChild(3).gameObject;
ultiCrystalController = ulticrystalObject.GetComponent<UltiCrystalController>();
ultiCrystalController.setPlayerController(this);
reminderController = ui.transform.GetChild(4).GetComponent<ReminderController>();
msfController = ui.transform.GetChild(5).GetComponent<MainScoreFlowController>();
citizenshipHealthController = ui.transform.GetChild(0).GetChild(1).GetComponent<HealthController>();
enemyUITarget = ui.transform.GetChild(6);
if (role == PlayerRole.Defender) {
for (int i = 0; i < enemyUITarget.childCount; i++){
enemyUITarget.GetChild(i).GetComponent<Image>().sprite = enemyIcons[2];
enemyUITarget.GetChild(i).GetChild(0).GetComponent<Image>().sprite = enemyIcons[3];
}
}
warningController = ui.transform.GetChild(7).GetComponent<WarningController>();
if (GameObject.Find("EventSystem") != null)
e = GameObject.Find("EventSystem").GetComponent<EventSystem>();
}
