public void CannotCreateInvalidTimeEntryFromForm()
{
// Establish Context
var timeEntryFromForm = new TimeEntry();
var viewModelToExpect = new TimeEntryFormViewModel();
_timeEntryManagementService.Expect(r => r.SaveOrUpdate(Arg <TimeEntry> .Is.Anything))
.Return(ActionConfirmation.CreateFailureConfirmation("not saved"));
_timeEntryManagementService.Expect(
r => r.CreateFormViewModelFor(Arg <TimeEntry> .Is.Anything, Arg <string> .Is.Anything))
.Return(viewModelToExpect);
_authenticationProvider.Expect(x => x.GetLoggedInUser()).Return("testuser");
_personManagementService.Expect(x => x.GetByUserName(Arg <string> .Is.Anything)).Return(
PersonInstanceFactory.CreateValidTransientPerson());
// Act
RedirectToRouteResult result =
_timeEntriesController.Create(timeEntryFromForm).AssertActionRedirect().ToAction("Index");
// Assert
//result.ViewData.Model.ShouldNotBeNull();
//(result.ViewData.Model as TimeEntryFormViewModel).ShouldNotBeNull();
//_timeEntriesController.TempData[ControllerEnums.GlobalViewDataProperty.PageMessage.ToString()].ToString().ShouldEqual("updated");
}
public void CanUpdateWithValidApplicationFromForm()
{
// Establish Context
Application validApplicationFromForm =
ApplicationInstanceFactory.CreateValidTransientApplication();
var validPerson = PersonInstanceFactory.CreateValidTransientPerson();
validApplicationFromForm.LastUpdateUser = 1;
validPerson.RoleId = 2;
// Intentionally empty to ensure successful transfer of values
var applicationFromDb = new Application {
ApplicationName = "Application Name 1", SupportTeamId = 1
};
_personManagementService.Expect(r => r.Get(Arg <int> .Is.Anything)).Return(validPerson);
_applicationRepository.Expect(r => r.Get(Arg <int> .Is.Anything))
.Return(applicationFromDb);
_personManagementService.Expect(r => r.Get(Arg <int> .Is.Anything)).Return(validPerson);
// Act
ActionConfirmation confirmation =
_applicationManagementService.UpdateWith(validApplicationFromForm, 1);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeTrue();
confirmation.Value.ShouldNotBeNull();
confirmation.Value.ShouldEqual(applicationFromDb);
confirmation.Value.ShouldEqual(validApplicationFromForm);
}
public void CannotUpdateInvalidApplicationFromForm()
{
// Establish Context
var applicationFromForm = new Application();
var viewModelToExpect = new ApplicationFormViewModel();
var testUser = PersonInstanceFactory.CreateValidTransientPerson();
testUser.SetAssignedIdTo(1);
_authenticationProvider.Expect(r => r.GetLoggedInUser()).Return("testuser");
_personManagementService.Expect(r => r.GetByUserName(Arg <string> .Is.Anything)).Return(testUser);
_applicationManagementService.Expect(r => r.UpdateWith(applicationFromForm, 0))
.Return(ActionConfirmation.CreateFailureConfirmation("not updated"));
_applicationManagementService.Expect(r => r.CreateFormViewModelFor(applicationFromForm))
.Return(viewModelToExpect);
// Act
ViewResult result =
_applicationsController.Edit(applicationFromForm).AssertViewRendered();
// Assert
result.ViewData.Model.ShouldNotBeNull();
(result.ViewData.Model as ApplicationFormViewModel).ShouldNotBeNull();
}
public void CanSaveOrUpdateValidPerson()
{
// Establish Context
Person validPerson =
PersonInstanceFactory.CreateValidTransientPerson();
// Act
ActionConfirmation confirmation =
_personManagementService.SaveOrUpdate(validPerson);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeTrue();
confirmation.Value.ShouldNotBeNull();
confirmation.Value.ShouldEqual(validPerson);
}
public void CanShowPerson()
{
// Establish Context
Person person =
PersonInstanceFactory.CreateValidTransientPerson();
_personManagementService.Expect(r => r.Get(1))
.Return(person);
// Act
ViewResult result = _peopleController.Show(1).AssertViewRendered();
// Assert
result.ViewData.Model.ShouldNotBeNull();
(result.ViewData.Model as Person).ShouldNotBeNull();
(result.ViewData.Model as Person).ShouldEqual(person);
}
public void CanGetPerson()
{
// Establish Context
Person personToExpect =
PersonInstanceFactory.CreateValidTransientPerson();
_personRepository.Expect(r => r.Get(1))
.Return(personToExpect);
// Act
Person personRetrieved =
_personManagementService.Get(1);
// Assert
personRetrieved.ShouldNotBeNull();
personRetrieved.ShouldEqual(personToExpect);
}
public void CanCreateFormViewModel()
{
// Establish Context
var viewModelToExpect = new TimeEntryFormViewModel();
_personManagementService.Expect(x => x.GetByUserName(Arg <string> .Is.Anything)).Return(
PersonInstanceFactory.CreateValidTransientPerson());
//_timeEntryRepository.Expect(x => x.GetRecentRequests(Arg<int>.Is.Anything)).Return(null);
// Act
TimeEntryFormViewModel viewModelRetrieved =
_timeEntryManagementService.CreateFormViewModel(DateTime.Today, "testuser");
// Assert
viewModelRetrieved.ShouldNotBeNull();
viewModelRetrieved.TimeEntry.ShouldBeNull();
}
public void CanCreateFormViewModelForPerson()
{
// Establish Context
var viewModelToExpect = new PersonFormViewModel();
Person person =
PersonInstanceFactory.CreateValidTransientPerson();
_personRepository.Expect(r => r.Get(1))
.Return(person);
// Act
PersonFormViewModel viewModelRetrieved =
_personManagementService.CreateFormViewModelFor(1);
// Assert
viewModelRetrieved.ShouldNotBeNull();
viewModelRetrieved.Person.ShouldNotBeNull();
viewModelRetrieved.Person.ShouldEqual(person);
}
public void CanUpdateValidTimeEntryFromForm()
{
// Establish Context
var timeEntryFromForm = new TimeEntry();
_timeEntryManagementService.Expect(r => r.UpdateWith(timeEntryFromForm, 0))
.Return(ActionConfirmation.CreateSuccessConfirmation("updated"));
_authenticationProvider.Expect(x => x.GetLoggedInUser()).Return("testuser");
_personManagementService.Expect(x => x.GetByUserName(Arg <string> .Is.Anything)).Return(
PersonInstanceFactory.CreateValidTransientPerson());
// Act
RedirectToRouteResult redirectResult =
_timeEntriesController.Edit(timeEntryFromForm)
.AssertActionRedirect().ToAction("Index");
// Assert
_timeEntriesController.TempData[ControllerEnums.GlobalViewDataProperty.PageMessage.ToString()].ToString()
.ShouldEqual("updated");
}
public void CanInitEdit()
{
// Establish Context
var viewModel = new ApplicationFormViewModel();
_applicationManagementService.Expect(r => r.CreateFormViewModelFor(Arg <int> .Is.Anything))
.Return(viewModel);
var testUser = PersonInstanceFactory.CreateValidTransientPerson();
testUser.SetAssignedIdTo(1);
_authenticationProvider.Expect(r => r.GetLoggedInUser()).Return("testuser");
_personManagementService.Expect(r => r.GetByUserName(Arg <string> .Is.Anything)).Return(testUser);
// Act
ViewResult result = _applicationsController.Edit(1).AssertViewRendered();
// Assert
result.ViewData.Model.ShouldNotBeNull();
(result.ViewData.Model as ApplicationFormViewModel).ShouldNotBeNull();
}
public void CanCreateValidRequestTypeFromForm()
{
// Establish Context
var requestTypeFromForm = new RequestType();
var testUser = PersonInstanceFactory.CreateValidTransientPerson();
testUser.SetAssignedIdTo(1);
_authenticationProvider.Expect(r => r.GetLoggedInUser()).Return("testuser");
_personManagementService.Expect(r => r.GetByUserName(Arg <string> .Is.Anything)).Return(testUser);
_requestTypeManagementService.Expect(r => r.SaveOrUpdate(requestTypeFromForm))
.Return(ActionConfirmation.CreateSuccessConfirmation("saved"));
// Act
RedirectToRouteResult redirectResult =
_requestTypesController.Create(requestTypeFromForm)
.AssertActionRedirect().ToAction("Index");
// Assert
_requestTypesController.TempData[ControllerEnums.GlobalViewDataProperty.PageMessage.ToString()].ToString()
.ShouldEqual("saved");
}
public void CanGetIncompleteWeeklyTimeForAllUsers()
{
IList <TimeEntryAudit> timeEntriesToExpect = new List <TimeEntryAudit>();
IList <Person> personsToExpect = new List <Person>();
TimeEntryAudit timeEntryAudit =
TimeEntryAuditInstanceFactory.CreateValidTransientTimeEntryAudit();
Person person = PersonInstanceFactory.CreateValidTransientPerson();
personsToExpect.Add(person);
_personManagementService.Expect(r => r.GetActiveStaff()).Return(personsToExpect);
IList <TimeEntryAuditDto> auditDtos =
_timeEntryAuditManagementService.GetIncompleteWeeklyTimeForAllUsers(Dates.GetPreviousSaturday());
foreach (var auditDto in auditDtos)
{
Console.WriteLine(String.Format("UserID:{0}, Hours:{1}", auditDto.UserId, auditDto.Hours));
Assert.That(float.Parse(auditDto.Hours, CultureInfo.InvariantCulture) < 40);
}
}
public void CannotUpdateInvalidTimeEntryFromForm()
{
// Establish Context
var timeEntryFromForm = new TimeEntry();
var viewModelToExpect = new TimeEntryFormViewModel();
_timeEntryManagementService.Expect(r => r.UpdateWith(timeEntryFromForm, 0))
.Return(ActionConfirmation.CreateFailureConfirmation("not updated"));
_timeEntryManagementService.Expect(
r => r.CreateFormViewModelFor(Arg <TimeEntry> .Is.Anything, Arg <string> .Is.Anything))
.Return(viewModelToExpect);
_authenticationProvider.Expect(r => r.GetLoggedInUser()).Return("testuser");
_personManagementService.Expect(x => x.GetByUserName(Arg <string> .Is.Anything)).Return(
PersonInstanceFactory.CreateValidTransientPerson());
// Act
ViewResult result =
_timeEntriesController.Edit(timeEntryFromForm).AssertViewRendered();
// Assert
result.ViewData.Model.ShouldNotBeNull();
(result.ViewData.Model as TimeEntryFormViewModel).ShouldNotBeNull();
}
public void CanUpdateWithValidPersonFromForm()
{
// Establish Context
Person validPersonFromForm =
PersonInstanceFactory.CreateValidTransientPerson();
// Intentionally empty to ensure successful transfer of values
var personFromDb = new Person();
_personRepository.Expect(r => r.Get(1))
.Return(personFromDb);
// Act
ActionConfirmation confirmation =
_personManagementService.UpdateWith(validPersonFromForm, 1);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeTrue();
confirmation.Value.ShouldNotBeNull();
confirmation.Value.ShouldEqual(personFromDb);
confirmation.Value.ShouldEqual(validPersonFromForm);
}
public void CanGetAllPeople()
{
// Establish Context
IList <Person> peopleToExpect = new List <Person>();
Person person =
PersonInstanceFactory.CreateValidTransientPerson();
peopleToExpect.Add(person);
_personRepository.Expect(r => r.GetAll("LastName", "Asc"))
.Return(peopleToExpect);
// Act
IList <Person> peopleRetrieved =
_personManagementService.GetAll();
// Assert
peopleRetrieved.ShouldNotBeNull();
peopleRetrieved.Count.ShouldEqual(1);
peopleRetrieved[0].ShouldNotBeNull();
peopleRetrieved[0].ShouldEqual(person);
}
public void CanCreateFormViewModelForTimeEntry()
{
// Establish Context
var viewModelToExpect = new TimeEntryFormViewModel();
_personManagementService.Expect(x => x.GetByUserName(Arg <string> .Is.Anything)).Return(
PersonInstanceFactory.CreateValidTransientPerson());
TimeEntry timeEntry =
TimeEntryInstanceFactory.CreateValidTransientTimeEntry();
_timeEntryRepository.Expect(r => r.Get(Arg <int> .Is.Anything))
.Return(timeEntry);
// Act
TimeEntryFormViewModel viewModelRetrieved =
_timeEntryManagementService.CreateFormViewModelFor(1, "testuser");
// Assert
viewModelRetrieved.ShouldNotBeNull();
viewModelRetrieved.TimeEntry.ShouldNotBeNull();
viewModelRetrieved.TimeEntry.ShouldEqual(timeEntry);
}
public void CannotUpdateWithInvalidApplicationFromForm()
{
// Establish Context
var invalidApplicationFromForm = new Application();
var validPerson = PersonInstanceFactory.CreateValidTransientPerson();
invalidApplicationFromForm.LastUpdateUser = 1;
// Intentionally empty to ensure successful transfer of values
var applicationFromDb = new Application();
_applicationRepository.Expect(r => r.Get(1))
.Return(applicationFromDb);
_personManagementService.Expect(r => r.Get(Arg <int> .Is.Anything)).Return(validPerson);
// Act
ActionConfirmation confirmation =
_applicationManagementService.UpdateWith(invalidApplicationFromForm, 1);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeFalse();
confirmation.Value.ShouldBeNull();
}
