private void bindGrid()
{
List <shift> allShifts = ShiftController.getAllShifts();
tet.DataSource = allShifts;
tet.DataBind();
}
public async Task Get_WhenShiftExists_ThenShiftShouldBeReturned()
{
// Arrange
var mockedPublisher = new Mock <IMessagePublisher>();
var mockedRepository = new Mock <IRepository>();
var shift = new Shift()
{
Id = 1, Day = new DateTime(2020, 2, 1), Type = ShiftType.ShiftFrom0To8, WorkerId = 3
};
mockedRepository.Setup(m => m.GetShift(It.IsAny <int>())).Returns(Task.FromResult(shift));
var controller = new ShiftController(mockedRepository.Object, mockedPublisher.Object);
// Act
var result = await controller.GetAsync(1);
var okResult = result as OkObjectResult;
// Assert
Assert.IsNotNull(okResult);
Assert.AreEqual(200, okResult.StatusCode);
var record = (Shift)okResult.Value;
Assert.AreEqual(1, record.Id);
Assert.AreEqual(3, record.WorkerId);
Assert.AreEqual(2020, record.Day.Year);
Assert.AreEqual(2, record.Day.Month);
Assert.AreEqual(1, record.Day.Day);
}
public void Add_WhenNewShift_ThenShiftShouldBeAdded()
{
// Arrange
var mockedPublisher = new Mock <IMessagePublisher>();
var mockedRepository = new Mock <IRepository>();
mockedRepository.Setup(m => m.AddShift(It.IsAny <AddShift>())).Returns(Task.FromResult(1));
mockedRepository.Setup(m => m.GetWorker(It.IsAny <int>()))
.Returns(Task.FromResult(new Worker()
{
Id = 1, FirstName = "Jan", LastName = "Hello"
}));
mockedRepository.Setup(m => m.GetShiftsPerWorker(It.IsAny <int>()))
.Returns(Task.FromResult((IList <Shift>) new List <Shift>()));
var controller = new ShiftController(mockedRepository.Object, mockedPublisher.Object);
var newShift = new AddShift()
{
Day = new DateTime(2020, 1, 1), Type = ShiftType.ShiftFrom0To8, WorkerId = 1
};
// Act
var result = controller.AddAsync(newShift);
var okResult = result.Result as OkObjectResult;
// Assert
Assert.IsNotNull(okResult);
Assert.AreEqual(200, okResult.StatusCode);
Assert.AreEqual(1, okResult.Value);
mockedPublisher.Verify(m => m.SendMessageShiftCreated(It.IsAny <Shift>()), Times.Once);
}
public async void Patch_No_Errors()
{
ShiftControllerMockFacade mock = new ShiftControllerMockFacade();
var mockResult = new Mock <UpdateResponse <ApiShiftResponseModel> >();
mockResult.SetupGet(x => x.Success).Returns(true);
mock.ServiceMock.Setup(x => x.Update(It.IsAny <int>(), It.IsAny <ApiShiftRequestModel>()))
.Callback <int, ApiShiftRequestModel>(
(id, model) => model.EndTime.Should().Be(TimeSpan.Parse("0"))
)
.Returns(Task.FromResult <UpdateResponse <ApiShiftResponseModel> >(mockResult.Object));
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiShiftResponseModel>(new ApiShiftResponseModel()));
ShiftController controller = new ShiftController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, new ApiShiftModelMapper());
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var patch = new JsonPatchDocument <ApiShiftRequestModel>();
patch.Replace(x => x.EndTime, TimeSpan.Parse("0"));
IActionResult response = await controller.Patch(default(int), patch);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
mock.ServiceMock.Verify(x => x.Update(It.IsAny <int>(), It.IsAny <ApiShiftRequestModel>()));
}
public void Setup()
{
var options = new DbContextOptionsBuilder <ShiftContext>()
.UseInMemoryDatabase(databaseName: "ShifttDatabase")
.Options;
// Insert seed data into the database using one instance of the context
shiftContext = new ShiftContext(options);
shiftContext.Shifts.Add(new Shift {
id = 1, employeeSlots = 6, shiftDate = DateTime.Now, workingEmployees = new List <User>()
{
new User(1, "Dave", 1), new User(2, "Steve", 1)
}
});
shiftContext.Shifts.Add(new Shift {
id = 2, employeeSlots = 6, shiftDate = DateTime.Now, workingEmployees = new List <User>()
{
new User(1, "Dave", 2), new User(2, "Steve", 2), new User(3, "Lisa", 2)
}
});
shiftContext.Shifts.Add(new Shift {
id = 3, employeeSlots = 6, shiftDate = DateTime.Now, workingEmployees = new List <User>()
});
shiftContext.SaveChanges();
shiftManager = new ShiftManager(shiftContext);
shiftController = new ShiftController(shiftManager);
}
public void Add_WhenNewShiftWithSameOrCloseTimes_ThenShiftShouldNotBeAdded(int year, int month, int day, ShiftType type,
int workerId)
{
// Arrange
var mockedPublisher = new Mock <IMessagePublisher>();
var mockedRepository = new Mock <IRepository>();
var shift = new Shift()
{
Day = new DateTime(year, month, day), Type = type, WorkerId = workerId
};
IList <Shift> list = new List <Shift>();
list.Add(shift);
mockedRepository.Setup(m => m.AddShift(It.IsAny <AddShift>())).Returns(Task.FromResult(1));
mockedRepository.Setup(m => m.GetWorker(It.IsAny <int>()))
.Returns(Task.FromResult(new Worker()
{
Id = 1, FirstName = "Jan", LastName = "Hello"
}));
mockedRepository.Setup(m => m.GetShiftsPerWorker(It.IsAny <int>())).Returns(Task.FromResult(list));
var controller = new ShiftController(mockedRepository.Object, mockedPublisher.Object);
var newShift = new AddShift()
{
Day = new DateTime(2020, 2, 2), Type = ShiftType.ShiftFrom0To8, WorkerId = 1
};
// Act
var result = controller.AddAsync(newShift);
// Assert
var exception = (AggregateException)result.Exception;
Assert.IsNotNull(exception);
}
public async void BulkInsert_No_Errors()
{
ShiftControllerMockFacade mock = new ShiftControllerMockFacade();
var mockResponse = new CreateResponse <ApiShiftResponseModel>(new FluentValidation.Results.ValidationResult());
mockResponse.SetRecord(new ApiShiftResponseModel());
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiShiftRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiShiftResponseModel> >(mockResponse));
ShiftController controller = new ShiftController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var records = new List <ApiShiftRequestModel>();
records.Add(new ApiShiftRequestModel());
IActionResult response = await controller.BulkInsert(records);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
var result = (response as OkObjectResult).Value as List <ApiShiftResponseModel>;
result.Should().NotBeEmpty();
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiShiftRequestModel>()));
}
protected void btnUpload_Click(object sender, EventArgs e)
{
if (fileUpload.HasFile)
{
if (Path.GetExtension(fileUpload.FileName) == ".xlsx")
{
ExcelPackage package = new ExcelPackage(fileUpload.FileContent);
DataTable dt = package.ToDataTable();
List <shift> toInsert = new List <shift>();
foreach (DataRow row in dt.Rows)
{
shift toAdd = new shift();
toAdd.ShiftName = row["ShiftName"].ToString();
toAdd.From = Convert.ToDateTime(row["Start_time"]);
toAdd.To = Convert.ToDateTime(row["End_time"]);
toAdd.DayName = row["DayOfWeek"].ToString();
toAdd.UserName = row["username"].ToString();
toInsert.Add(toAdd);
}
ShiftController.InsertShifts(toInsert);
bindGrid();
}
}
}
public async Task UploadShifts_CsvFile_AddShifts()
{
// Arrange
IRepository <Shift> shiftRepository = Substitute.For <IRepository <Shift> >();
IRepository <Organization> organizationRepository = Substitute.For <IRepository <Organization> >();
Microsoft.Graph.IGraphServiceClient graphServiceClient = Substitute.For <Microsoft.Graph.IGraphServiceClient>();
IStringLocalizer <ShiftController> stringLocalizer = Substitute.For <IStringLocalizer <ShiftController> >();
ShiftController controller = new ShiftController(shiftRepository, organizationRepository, graphServiceClient, stringLocalizer);
FileUploadViewModel viewModel = new FileUploadViewModel {
StoreName = "Contoso"
};
string content = "Start, End, Type\n2020-04-10T09:00,2020-04-10T17:00,Shelf Stacker\n2020-04-10T10:00,2020-04-10T18:00,Tills";
byte[] contentBytes = Encoding.UTF8.GetBytes(content);
viewModel.FormFile = new FormFile(new MemoryStream(contentBytes), 0, contentBytes.Length, null, "shifts.csv")
{
Headers = new HeaderDictionary(),
ContentType = "csv"
};
// Act
await controller.UploadShifts(viewModel);
#pragma warning disable 4014
// Assert
shiftRepository.Received(1).Add(Arg.Is <Shift>(x => x.Start == DateTime.Parse("2020-04-10T09:00")));
shiftRepository.Received(1).Add(Arg.Is <Shift>(x => x.Start == DateTime.Parse("2020-04-10T10:00")));
#pragma warning restore 4014
}
public ShiftsForm(EmployeeController empController)
{
InitializeComponent();
this.Load += ShiftsForm_Load;
this.FormClosed += ShiftsForm_Closed;
employeeController = empController;
shiftController = new ShiftController(employeeController);
}
public ShiftControllerTests() : base(false)
{
var environment = new EnvironmentBuilder("LocationServicesClient:Username", "LocationServicesClient:Password", "LocationServicesClient:Url");
ShiftController = new ShiftController(new ShiftService(Db, new SheriffService(Db), environment.Configuration), Db)
{
ControllerContext = HttpResponseTest.SetupMockControllerContext()
};
}
public void ScheduleEngineersShift_AllValuesNull_Error()
{
Mock <IShiftService> mockService = new Mock <IShiftService>(MockBehavior.Strict);
ShiftController controller = new ShiftController(mockService.Object);
var result = controller.ScheduleEngineersShift(null);
Assert.NotNull(result);
Assert.True(result.GetType() == typeof(BadRequestObjectResult));
Assert.Equal("All values must be informed.", (result as BadRequestObjectResult).Value);
mockService.Verify(m => m.ScheduleEngineerShift(It.IsAny <ShiftRequestModel>()), Times.Never());
}
public void ScheduleEngineersShift_Count_Empty_Error()
{
Mock <IShiftService> mockService = new Mock <IShiftService>(MockBehavior.Strict);
ShiftController controller = new ShiftController(mockService.Object);
var result = controller.ScheduleEngineersShift(new ShiftRequestModel {
StartDate = DateTime.Now.NextBusinessDay()
});
Assert.NotNull(result);
Assert.True(result.GetType() == typeof(BadRequestObjectResult));
Assert.Equal("The number of support engineers is required.", (result as BadRequestObjectResult).Value);
mockService.Verify(m => m.ScheduleEngineerShift(It.IsAny <ShiftRequestModel>()), Times.Never);
}
public void ScheduleEngineersShift_Date_Weekend_Error()
{
Mock <IShiftService> mockService = new Mock <IShiftService>(MockBehavior.Strict);
ShiftController controller = new ShiftController(mockService.Object);
var result = controller.ScheduleEngineersShift(new ShiftRequestModel {
Count = 1, StartDate = new DateTime(2017, 12, 17)
});
Assert.NotNull(result);
Assert.True(result.GetType() == typeof(BadRequestObjectResult));
Assert.Equal("Weekends are not valid working days.", (result as BadRequestObjectResult).Value);
mockService.Verify(m => m.ScheduleEngineerShift(It.IsAny <ShiftRequestModel>()), Times.Never);
}
public ShiftsForm(EmployeeController empController)
{
InitializeComponent();
//the form will subscribe to its Load & the FormClosed events and to the DateSelected event of the shiftsMonthcalendar control
//the name of the methods that will execute in each case is given on the right hand side of the "+=" symbol
this.Load += ShiftsForm_Load;
this.FormClosed += ShiftsForm_Closed;
shiftsMonthCalendar.DateSelected += ShiftsMonthCalendar_DateSelected;
employeeController = empController;
shiftController = new ShiftController(employeeController);
shiftController.NoMoreShifts += ShiftController_NoMoreShifts;
shiftController.OnShift += ShiftController_OnShift;
}
public ShiftControllerTests() : base(false)
{
var environment = new EnvironmentBuilder("LocationServicesClient:Username", "LocationServicesClient:Password", "LocationServicesClient:Url");
var shiftService = new ShiftService(Db, new SheriffService(Db, environment.Configuration),
environment.Configuration);
var dutyRosterService = new DutyRosterService(Db, environment.Configuration,
shiftService, environment.LogFactory.CreateLogger <DutyRosterService>());
ShiftController = new ShiftController(shiftService, dutyRosterService, Db, environment.Configuration)
{
ControllerContext = HttpResponseTest.SetupMockControllerContext()
};
}
public void ScheduleEngineersShift_Date_Empty_Error()
{
Mock <IShiftService> mockService = new Mock <IShiftService>(MockBehavior.Strict);
ShiftController controller = new ShiftController(mockService.Object);
var result = controller.ScheduleEngineersShift(new ShiftRequestModel {
Count = 1
});
Assert.NotNull(result);
Assert.True(result.GetType() == typeof(BadRequestObjectResult));
Assert.Equal("Date value cannot be empty.", (result as BadRequestObjectResult).Value);
mockService.Verify(m => m.ScheduleEngineerShift(It.IsAny <ShiftRequestModel>()), Times.Never);
}
public async void Get_Not_Exists()
{
ShiftControllerMockFacade mock = new ShiftControllerMockFacade();
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiShiftResponseModel>(null));
ShiftController controller = new ShiftController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Get(default(int));
response.Should().BeOfType <StatusCodeResult>();
(response as StatusCodeResult).StatusCode.Should().Be((int)HttpStatusCode.NotFound);
mock.ServiceMock.Verify(x => x.Get(It.IsAny <int>()));
}
public void ScheduleEngineersShift_Exception()
{
Mock <IShiftService> mockService = new Mock <IShiftService>(MockBehavior.Strict);
mockService.Setup(s => s.ScheduleEngineerShift(It.IsAny <ShiftRequestModel>())).Throws(new InvalidOperationException("Testing controller exception handler"));
ShiftController controller = new ShiftController(mockService.Object);
var result = controller.ScheduleEngineersShift(new ShiftRequestModel {
Count = 1, StartDate = DateTime.Now.NextBusinessDay()
});
Assert.NotNull(result);
Assert.True(result.GetType() == typeof(BadRequestObjectResult));
Assert.Equal("Testing controller exception handler", (result as BadRequestObjectResult).Value);
mockService.Verify(m => m.ScheduleEngineerShift(It.IsAny <ShiftRequestModel>()), Times.Once());
}
public void ScheduleEngineersShiftRange_Success()
{
Mapper.Initialize(cfg =>
{
cfg.AddProfile <BAUMappingProfile>();
});
var date = DateTime.Now.NextDayOfWeek(DayOfWeek.Thursday);
Mock <IShiftService> mockService = new Mock <IShiftService>(MockBehavior.Strict);
mockService.Setup(s => s.ScheduleEngineerShiftRange(It.IsAny <ShiftRequestModel>()))
.Returns(
new List <EngineerShiftModel> {
new EngineerShiftModel {
Date = date, Duration = 4, Engineer = new EngineerModel {
Id = 1, Name = "Engineer 1"
}
},
new EngineerShiftModel {
Date = date.NextDayOfWeek(DayOfWeek.Tuesday), Duration = 4, Engineer = new EngineerModel {
Id = 2, Name = "Engineer 2"
}
},
});
ShiftController controller = new ShiftController(mockService.Object);
var model = new ShiftRequestModel
{
Count = 2,
StartDate = date,
EndDate = date.NextDayOfWeek(DayOfWeek.Tuesday)
};
var result = controller.ScheduleEngineersShiftRange(model);
Assert.NotNull(result);
Assert.True(result.GetType() == typeof(OkObjectResult));
var expected = new List <EngineerModel> {
new EngineerModel {
Id = 1, Name = "Engineer 1"
},
new EngineerModel {
Id = 2, Name = "Engineer 2"
},
};
Assert.Equal(expected, (result as OkObjectResult).Value);
mockService.Verify(m => m.ScheduleEngineerShiftRange(model), Times.Once());
}
public void Get_WhenShiftDoesNotExist_Then404ShouldBeReturned()
{
// Arrange
var mockedPublisher = new Mock <IMessagePublisher>();
var mockedRepository = new Mock <IRepository>();
mockedRepository.Setup(m => m.GetShift(It.IsAny <int>())).Returns(Task.FromResult((Shift)null));
var controller = new ShiftController(mockedRepository.Object, mockedPublisher.Object);
// Act
var result = controller.GetAsync(1);
var notFoundResult = result.Result as NotFoundResult;
// Assert
Assert.IsNotNull(notFoundResult);
Assert.AreEqual(404, notFoundResult.StatusCode);
}
public void ScheduleEngineersShift_Success()
{
if (Mapper.Instance == null)
{
Mapper.Initialize(cfg =>
{
cfg.AddProfile <BAUMappingProfile>();
});
}
Mock <IShiftService> mockService = new Mock <IShiftService>(MockBehavior.Strict);
mockService.Setup(s => s.ScheduleEngineerShift(It.IsAny <ShiftRequestModel>()))
.Returns(
new List <EngineerShiftModel> {
new EngineerShiftModel {
Date = DateTime.Now, Duration = 4, Engineer = new EngineerModel {
Id = 1, Name = "Engineer 1"
}
},
new EngineerShiftModel {
Date = DateTime.Now, Duration = 4, Engineer = new EngineerModel {
Id = 2, Name = "Engineer 2"
}
},
});
ShiftController controller = new ShiftController(mockService.Object);
var result = controller.ScheduleEngineersShift(new ShiftRequestModel {
Count = 1, StartDate = new DateTime(2017, 12, 18)
});
Assert.NotNull(result);
Assert.True(result.GetType() == typeof(OkObjectResult));
var expected = new List <EngineerModel> {
new EngineerModel {
Id = 1, Name = "Engineer 1"
},
new EngineerModel {
Id = 2, Name = "Engineer 2"
},
};
Assert.Equal(expected, (result as OkObjectResult).Value);
mockService.Verify(m => m.ScheduleEngineerShift(It.IsAny <ShiftRequestModel>()), Times.Once());
}
public async void Delete_Errors()
{
ShiftControllerMockFacade mock = new ShiftControllerMockFacade();
var mockResult = new Mock <ActionResponse>();
mockResult.SetupGet(x => x.Success).Returns(false);
mock.ServiceMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.FromResult <ActionResponse>(mockResult.Object));
ShiftController controller = new ShiftController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Delete(default(int));
response.Should().BeOfType <ObjectResult>();
(response as ObjectResult).StatusCode.Should().Be((int)HttpStatusCode.UnprocessableEntity);
mock.ServiceMock.Verify(x => x.Delete(It.IsAny <int>()));
}
public void Remove_WhenShiftExists_ThenShiftShouldBeReturned()
{
// Arrange
var mockedRepository = new Mock <IRepository>();
var mockedPublisher = new Mock <IMessagePublisher>();
mockedRepository.Setup(m => m.RemoveShift(It.IsAny <int>())).Returns(Task.FromResult(RemoveShiftStatus.Ok));
var controller = new ShiftController(mockedRepository.Object, mockedPublisher.Object);
// Act
var result = controller.RemoveAsync(1);
var okResult = result.Result as OkResult;
// Assert
Assert.IsNotNull(okResult);
Assert.AreEqual(200, okResult.StatusCode);
mockedPublisher.Verify(m => m.SendMessageShiftRemoved(It.IsAny <Shift>()), Times.Once);
}
public async void All_Not_Exists()
{
ShiftControllerMockFacade mock = new ShiftControllerMockFacade();
mock.ServiceMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult <List <ApiShiftResponseModel> >(new List <ApiShiftResponseModel>()));
ShiftController controller = new ShiftController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.All(1000, 0);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
var items = (response as OkObjectResult).Value as List <ApiShiftResponseModel>;
items.Should().BeEmpty();
mock.ServiceMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
}
public async void Update_NotFound()
{
ShiftControllerMockFacade mock = new ShiftControllerMockFacade();
var mockResult = new Mock <UpdateResponse <ApiShiftResponseModel> >();
mockResult.SetupGet(x => x.Success).Returns(false);
mock.ServiceMock.Setup(x => x.Update(It.IsAny <int>(), It.IsAny <ApiShiftRequestModel>())).Returns(Task.FromResult <UpdateResponse <ApiShiftResponseModel> >(mockResult.Object));
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiShiftResponseModel>(null));
ShiftController controller = new ShiftController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, new ApiShiftModelMapper());
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Update(default(int), new ApiShiftRequestModel());
response.Should().BeOfType <StatusCodeResult>();
(response as StatusCodeResult).StatusCode.Should().Be((int)HttpStatusCode.NotFound);
mock.ServiceMock.Verify(x => x.Get(It.IsAny <int>()));
}
public void Remove_WhenShiftDoesNotExist_ThenExceptionShouldBeReturned()
{
// Arrange
var mockedPublisher = new Mock <IMessagePublisher>();
var mockedRepository = new Mock <IRepository>();
mockedRepository.Setup(m => m.RemoveShift(It.IsAny <int>()))
.Returns(Task.FromResult(RemoveShiftStatus.RecordDoesNotExist));
var controller = new ShiftController(mockedRepository.Object, mockedPublisher.Object);
Task <IActionResult> result = null;
// Act
result = controller.RemoveAsync(1);
// Assert
var exception = (AggregateException)result.Exception;
Assert.IsNotNull(exception);
}
public async void Patch_Record_Not_Found()
{
ShiftControllerMockFacade mock = new ShiftControllerMockFacade();
var mockResult = new Mock <ActionResponse>();
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiShiftResponseModel>(null));
ShiftController controller = new ShiftController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var patch = new JsonPatchDocument <ApiShiftRequestModel>();
patch.Replace(x => x.EndTime, TimeSpan.Parse("0"));
IActionResult response = await controller.Patch(default(int), patch);
response.Should().BeOfType <StatusCodeResult>();
(response as StatusCodeResult).StatusCode.Should().Be((int)HttpStatusCode.NotFound);
mock.ServiceMock.Verify(x => x.Get(It.IsAny <int>()));
}
public void ScheduleEngineersShiftRange_EndDate_Error()
{
Mock <IShiftService> mockService = new Mock <IShiftService>(MockBehavior.Strict);
mockService.Setup(s => s.ScheduleEngineerShiftRange(It.IsAny <ShiftRequestModel>()));//.Returns(new List<EngineerShiftModel>());
ShiftController controller = new ShiftController(mockService.Object);
var date = DateTime.Now.NextDayOfWeek(DayOfWeek.Thursday);
var model = new ShiftRequestModel
{
Count = 2,
StartDate = date.NextDayOfWeek(DayOfWeek.Tuesday),
EndDate = date
};
var result = controller.ScheduleEngineersShiftRange(model);
Assert.NotNull(result);
Assert.True(result.GetType() == typeof(BadRequestObjectResult));
Assert.Equal("The final date must be greater than the initial date.", (result as BadRequestObjectResult).Value);
mockService.Verify(m => m.ScheduleEngineerShiftRange(It.IsAny <ShiftRequestModel>()), Times.Never());
}
protected void Page_Load(object sender, EventArgs e)
{
if (SessionManager.GetCurrentUser().EmployeeType != Entities.EmplpyeeType.INTERPRETER)
{
Response.Redirect("Default.aspx");
}
string v = Request.QueryString["room"];
if (v != null)
{
hdnRoomId.Value = v;
}
hdnSource.Value = SessionManager.GetCurrentUser().EmployeId.ToString();
if (!IsPostBack)
{
List <shift> myShifts = ShiftController.getShiftByUserName(SessionManager.GetCurrentUser().EmployeId);
gvmyShifts.DataSource = myShifts;
gvmyShifts.DataBind();
}
}
public static ShiftController Fixture()
{
ShiftController controller = new ShiftController(new ShiftRepository(), "", new LoginView());
return controller;
}
