public static async Task Adds_recalculation_trigger_when_saving_requests()
{
var activeDates = new[] { 2.February(2021) };
var mockRequestRepository =
CreateRequestRepository.MockWithRequests(UserId, activeDates, new List <Request>());
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var mockTriggerRepository = new Mock <ITriggerRepository>();
var patchRequest = new RequestsPatchRequest(new List <RequestsPatchRequestDailyData>());
var controller = new RequestsController(
CreateDateCalculator.WithActiveDates(activeDates),
mockRequestRepository.Object,
mockTriggerRepository.Object,
CreateUserRepository.WithUsers(DefaultUsers))
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
await controller.PatchAsync(patchRequest);
mockTriggerRepository.Verify(r => r.AddTrigger(), Times.Once);
}
public async void CreateRequestUserIsNull_BadRequest()
{
// Arrange
User user = new User {
Id = 1, FirstName = "Den"
};
Apartment apartment = new Apartment {
Id = 1
};
Mock <UserRepository> mockUserRepository = new Mock <UserRepository>();
mockUserRepository
.Setup(ur => ur.GetAsync(It.IsAny <int>(), It.IsAny <string>()))
.Returns(Task.FromResult(null as User));
Mock <IUnitOfWork> mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork
.Setup(u => u.GetRepository <User, UserRepository>())
.Returns(mockUserRepository.Object);
RequestsController controller = new RequestsController(mockUnitOfWork.Object);
// Act
IActionResult result = await controller.CreateRequest(user.Id, apartment.Id);
// Assert
Assert.NotNull(result);
BadRequestObjectResult badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal("User does not exist", badRequestObjectResult.Value.ToString());
}
public static async Task Returns_updated_requests_after_saving()
{
var activeDates = new[] { 2.February(2021), 3.February(2021) };
var returnedRequests = new[] { new Request(UserId, 2.February(2021), RequestStatus.Pending) };
var mockRequestRepository =
CreateRequestRepository.MockWithRequests(UserId, activeDates, returnedRequests);
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var patchRequest =
new RequestsPatchRequest(new[] { new RequestsPatchRequestDailyData(2.February(2021), true) });
var controller = new RequestsController(
CreateDateCalculator.WithActiveDates(activeDates),
mockRequestRepository.Object,
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(DefaultUsers))
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
var result = await controller.PatchAsync(patchRequest);
var resultValue = GetResultValue <RequestsResponse>(result);
var day1data = GetDailyData(resultValue.Requests, 2.February(2021));
var day2data = GetDailyData(resultValue.Requests, 3.February(2021));
Assert.True(day1data.Requested);
Assert.False(day2data.Requested);
}
static void Main(string[] args)
{
var _context = new prs0Context();
var vendors = _context.Vendors.ToList();
// gets a single value if exist or return null
var bbuy = _context.Vendors.SingleOrDefault(v => v.Code == "BBUY");
var ReqCtrl = new RequestsController(_context);
var requestInReview = ReqCtrl.GetRequestsInReview();
var updTotal = ReqCtrl.RecalculateRequestTotal(1);
var req1 = _context.Requests.Find(1);
var ok = ReqCtrl.ReviewRequest(req1);
var req3 = _context.Requests.Find(3);
ok = ReqCtrl.ReviewRequest(req3);
var req2 = _context.Requests.Find(2);
var isWorked = ReqCtrl.SetToApproved(req2);
var UserCtrl = new UsersController(_context);
// Tests the login functio
var yyuser = UserCtrl.Login("yy", "yy");
var sauser = UserCtrl.Login("sa", "sa");
}
public static async Task Updates_data_for_given_user_when_specified()
{
var activeDates = new[] { 2.February(2021) };
var mockRequestRepository =
CreateRequestRepository.MockWithRequests(UserId, activeDates, new List <Request>());
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var patchRequest = new RequestsPatchRequest(new[]
{
new RequestsPatchRequestDailyData(2.February(2021), true),
new RequestsPatchRequestDailyData(3.February(2021), false),
});
var controller = new RequestsController(
CreateDateCalculator.WithActiveDates(activeDates),
mockRequestRepository.Object,
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUserExistsAndUsers(UserId, true, DefaultUsers));
await controller.PatchByIdAsync(UserId, patchRequest);
var expectedSavedRequests = new[] { new Request(UserId, 2.February(2021), RequestStatus.Pending) };
CheckSavedRequests(mockRequestRepository, expectedSavedRequests, DefaultUsers);
}
private RequestsController CreateController()
{
var sut = new RequestsController(
_mockTranscriptRequestRepository.Object,
_mockTranscriptRequestService.Object,
_mockInstitutionRepository.Object,
_mockLinqWrapperService.Object,
_mockTranscriptRepository.Object,
_mockTranscriptService.Object,
_mockTranscriptProviderService.Object);
var claimCollection = new Claim[] {
new Claim(CcClaimType.UserType.ToString(), "Student"),
new Claim(CcClaimType.StudentPortfolioId.ToString(), "123"),
new Claim(CcClaimType.UserAccountId.ToString(), "456"),
new Claim(CcClaimType.EducatorId.ToString(), "789")
};
sut.ControllerContext.HttpContext = new DefaultHttpContext
{
User = new TestPrincipal(claimCollection)
};
return(sut);
}
public void RequestsControllerPostTestWithRanges()
{
var type = CreateContext();
var additionalField = CreateFieldLogicWithRanges(type);
var RequestId = Guid.NewGuid();
var AdditionalFieldValueList = CreateFields(additionalField, RequestId, "01/15/1993");
var Logic = CreateLogic();
var Controller = new RequestsController(Logic);
Request Request = new Request()
{
Id = RequestId,
RequestorsName = "Just Testing",
RequestorsEmail = "*****@*****.**",
RequestorsPhone = "489498948894",
TypeId = type.Id,
AdditionalFieldValues = AdditionalFieldValueList
};
var result = Controller.Post(RequestDTO.ToModel(Request));
var createdResult = result as CreatedAtRouteResult;
var model = createdResult.Value as RequestDTO;
Assert.AreEqual(Request.AdditionalFieldValues.Count, model.AdditionalFieldValues.Count);
}
public async void AcceptRequestRequestIsNull_BadRequest()
{
// Arrange
Request request = new Request {
Id = 5
};
Mock <RequestRepository> mockRequestRepository = new Mock <RequestRepository>();
mockRequestRepository
.Setup(rr => rr.Get(It.IsAny <Expression <Func <Request, bool> > >(),
It.IsAny <Func <IQueryable <Request>, IOrderedQueryable <Request> > >(),
It.IsAny <string>(), It.IsAny <int>(),
It.IsAny <int>()))
.Returns(null as IEnumerable <Request>);
Mock <IUnitOfWork> mockIUnitOfWork = new Mock <IUnitOfWork>();
mockIUnitOfWork
.Setup(u => u.GetRepository <Request, RequestRepository>())
.Returns(mockRequestRepository.Object);
RequestsController controller = new RequestsController(mockIUnitOfWork.Object);
// Act
IActionResult result = await controller.AcceptRequest(request.Id);
// Assert
Assert.NotNull(result);
BadRequestObjectResult badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal("No request found", badRequestObjectResult.Value.ToString());
}
public RequestsControllerTest(ApplicationDbContextFixture contextFixture)
{
Context = contextFixture.DbContext;
RoleManager = contextFixture.RoleManager;
UserManager = contextFixture.UserManager;
Controller = new RequestsController(Context, UserManager, RoleManager);
Moderador = UserManager.FindByNameAsync("ModeradorTeste").Result;
Cliente = UserManager.FindByNameAsync("InêsBotelho").Result;
ClienteRole = RoleManager.FindByNameAsync("Cliente").Result;
ModeradoresRole = RoleManager.FindByNameAsync("Moderador").Result;
ProvidersRole = RoleManager.FindByNameAsync("Prestador").Result;
ModeradorLog = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim>()
{
new Claim(ClaimTypes.Name, Moderador.UserName),
new Claim(ClaimTypes.Email, Moderador.Email),
new Claim(ClaimTypes.NameIdentifier, Moderador.Id),
new Claim(ClaimTypes.Role, ModeradoresRole.Name),
}, "Test"));
ClientLog = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim>()
{
new Claim(ClaimTypes.Name, Cliente.UserName),
new Claim(ClaimTypes.Email, Cliente.Email),
new Claim(ClaimTypes.NameIdentifier, Cliente.Id),
new Claim(ClaimTypes.Role, ClienteRole.Name),
}, "Test"));
}
public static async Task Does_not_update_requests_outside_active_date_range()
{
var activeDates = new[] { 2.February(2021), 3.February(2021) };
var mockRequestRepository =
CreateRequestRepository.MockWithRequests(UserId, activeDates, new List <Request>());
mockRequestRepository
.Setup(r => r.SaveRequests(It.IsAny <IReadOnlyCollection <Request> >(), It.IsAny <IReadOnlyCollection <User> >()))
.Returns(Task.CompletedTask);
var patchRequest = new RequestsPatchRequest(new[]
{
new RequestsPatchRequestDailyData(1.February(2021), true),
new RequestsPatchRequestDailyData(4.February(2021), true)
});
var controller = new RequestsController(
CreateDateCalculator.WithActiveDates(activeDates),
mockRequestRepository.Object,
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUsers(DefaultUsers))
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
await controller.PatchAsync(patchRequest);
CheckSavedRequests(mockRequestRepository, new List <Request>(), DefaultUsers);
}
public void List_ViewResult()
{
// Arrange
int userId = 1;
IEnumerable <Request> requests = new List <Request>
{
new Request {
Id = 1
},
new Request {
Id = 2
}
};
Mock <RequestRepository> mockRequestRepository = new Mock <RequestRepository>();
mockRequestRepository
.Setup(rr => rr.Get(It.IsAny <Expression <Func <Request, bool> > >(),
It.IsAny <Func <IQueryable <Request>, IOrderedQueryable <Request> > >(),
It.IsAny <string>(), It.IsAny <int>(),
It.IsAny <int>()))
.Returns(requests);
Mock <IUnitOfWork> mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork
.Setup(u => u.GetRepository <Request, RequestRepository>())
.Returns(mockRequestRepository.Object);
ControllerBase controller = new RequestsController(mockUnitOfWork.Object);
Mock <ClaimsPrincipal> userMock = new Mock <ClaimsPrincipal>();
userMock
.Setup(p => p.FindFirst(It.IsAny <string>()))
.Returns(new Claim(nameof(User.Id), userId.ToString()));
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext()
{
User = userMock.Object
}
};
// Act
IActionResult result = (controller as RequestsController)?.List();
// Assert
Assert.NotNull(result);
ViewResult viewResult = Assert.IsType <ViewResult>(result);
Assert.NotNull(viewResult.Model);
ListViewModel listViewModel = Assert.IsType <ListViewModel>(viewResult.Model);
Assert.Equal(userId, listViewModel.UserId);
Assert.Same(requests, listViewModel.Requests);
Assert.Null(viewResult.ViewName);
}
public async Task WhenDeclineRequestsGetCalled()
{
Setup();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(false);
_result = await RequestsController.DeclineRequest(_userId, _senderId, RequestTypeId);
}
public async Task WhenAcceptRequestsGetCalled()
{
Setup();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestValidator.Setup(validator => validator.ValidateAcceptRequest(It.IsAny <Request>())).ReturnsAsync(new List <Error>());
_result = await RequestsController.AcceptRequest(_userId, _senderId, RequestTypeId);
}
public void Index_WithoutFilter_ReturnsAllRequests()
{
var requests = new[]
{
new Request
{
Id = 1,
AssignedTo = new User(),
Requester = new User(),
Status = new RequestStatus()
},
new Request
{
Id = 2,
AssignedTo = new User(),
Requester = new User(),
Status = new RequestStatus()
}, new Request
{
Id = 3,
AssignedTo = new User(),
Requester = new User(),
Status = new RequestStatus()
},
};
this.dbContext.Requests.AddRange(requests);
this.dbContext.SaveChanges();
var mockUserManager = TestsUserManager.GetUserManager();
var controller = new RequestsController(this.dbContext, TestsAutoMapper.GetMapper(), mockUserManager.Object, requestservice);
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.Role, WebConstants.AdminRole)
}))
}
};
var result = controller.Index("", "", "", null, 1) as ViewResult;
var model = result.Model as RequestSortingViewModel;
//the default sorting order is Id => desc
var expectedCollection = requests.Select(r => r.Id).OrderByDescending(r => r).ToArray();
var resultCollection = model.RequestListingViewModels.Select(rv => rv.Id).ToArray();
Assert.IsNotNull(result);
CollectionAssert.AreEqual(expectedCollection, resultCollection);
}
static void Main(string[] args)
{
//create new instance of prsContext class and store data in the instance _context
var _context = new prsContext();
var vendors = _context.Vendors.ToList();
var IKEA = _context.Vendors.SingleOrDefault(v => v.Code == "IKEA");
//pass the instance of _context into method RequestsController and store in instance ReqCtrl
var RequCtrl = new RequestsController(_context);
//check review status and return anything with review. brings up two rows in Request
var requestInReview = RequCtrl.GetRequestsInReview();
//instance ReqCtrl.method - calls Re method and passes in the parameter 1 which is the Id of 1 and store it in instance updTotal
var updTotal = RequCtrl.RecalculateRequestTotal(1);
//check to see if it gets approved and rejected
var req2 = _context.Requests.Find(2);
var worked = RequCtrl.SetToApproved(req2);
var reject = RequCtrl.SetToRejected(req2);
//to check and see if the request is over 50.00 gets reviewed
var req3 = _context.Requests.Find(3);
var req4 = _context.Requests.Find(4);
RequCtrl.ReviewRequest(req3);
RequCtrl.ReviewRequest(req4);
var UserCtrl = new UsersController(_context);
//test login function
var pheebs = UserCtrl.Login("PBuffay", "Smellycat");
var who = UserCtrl.Login("xx", "yy");//should be null
//retrieve all rows and columns from the Users database which is a collection of data and store it in users
//the following line connects to the database, opens the database, reads data, retrieves data,
//closes the reader and closes the database
//var users = _context.Users.ToList();
////retrieve the row with a primary key of 1 using the Find()
//var user1 = _context.Users.Find(1);
////update a Phone number is user1 record(row). need to save changes when finished. open SQl Users table to see if phone number changed
//user1.PhoneNumber = "513-555-1212";
//_context.SaveChanges();
////example for Vendor
//var vendors = _context.Vendor.ToList();
//var bbuy = _context.Vendor.SingleOrDefault(v => v.Code == "BSTBY");
var users = _context.Users.ToList();
//find a user and change the information
var users1 = _context.Users.Find(7);
users1.PhoneNumber = "513-555-7777";
_context.SaveChanges();
}
public RequestControllerTests()
{
_fixture = new Fixture();
_fixture.Customize(new RandomBooleanSequenceCustomization());
_requestSrvMock = new Mock <IRequestSrv>();
_mapperMock = new Mock <IMapper>();
_loggerMock = new Mock <ILogger <RequestsController> >();
_controller = new RequestsController(_mapperMock.Object, _requestSrvMock.Object,
_loggerMock.Object);
}
public void Setup()
{
RequestsRepository = new Mock <IRequestsRepository>();
RequestsService = new Mock <IRequestsService>();
AuthService = new Mock <IAuthService>();
RequestValidator = new Mock <IRequestValidator>();
RequestsController = new RequestsController(RequestsService.Object, RequestsRepository.Object, AuthService.Object, RequestValidator.Object);
RequestsController.ControllerContext = new ControllerContext();
RequestsController.ControllerContext.HttpContext = new DefaultHttpContext();
RequestsController.ControllerContext.HttpContext.Request.Headers.Add("Authorization", "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJCb2IgSmVua2lucyIsImp0aSI6IjAzZTE2MGMyLWZhNWItNDg0NS1hMjMwLTU5MDZlZTU1NWY1ZSIsImV4cCI6MTg5MzcwMTYyNywiaXNzIjoibG9jYWxob3N0OjUwMDEiLCJhdWQiOiJsb2NhbGhvc3Q6NTAwMSJ9.C9_Y29A0ky2tObFpp7vyvm3vjlxSU4Tmfj_B1Mvyfh4");
}
public async Task WhenGetOutgoingRequestsGetCalled()
{
Setup();
_requests = new Fixture().CreateMany <Request>().ToList();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestsRepository.Setup(repository => repository.GetRequestsBySenderId(_userId))
.ReturnsAsync(_requests);
_result = await RequestsController.GetOutgoingRequests(_userId);
}
public static async Task Returns_404_response_when_given_user_does_not_exist()
{
var controller = new RequestsController(
Mock.Of <IDateCalculator>(),
Mock.Of <IRequestRepository>(),
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUserExists(UserId, false));
var result = await controller.GetByIdAsync(UserId);
Assert.IsType <NotFoundResult>(result);
}
public async Task WhenDeclineRequestsGetCalled()
{
Setup();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestsRepository
.Setup(repository => repository
.GetRequestByUserIdsAndType(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <RequestType>()))
.ReturnsAsync((Request)null);
_result = await RequestsController.DeclineRequest(_userId, _senderId, RequestTypeId);
}
public async void DeleteRequest_OkResult()
{
// Arrange
User user = new User {
Id = 1, FirstName = "Den"
};
Apartment apartment = new Apartment {
Id = 1
};
Request request = new Request {
Id = 1
};
Mock <UserRepository> mockUserRepository = new Mock <UserRepository>();
mockUserRepository
.Setup(ur => ur.GetAsync(It.IsAny <int>(), It.IsAny <string>()))
.Returns(Task.FromResult(user));
Mock <ApartmentRepository> mockApartmentRepository = new Mock <ApartmentRepository>();
mockApartmentRepository
.Setup(ur => ur.GetAsync(It.IsAny <int>(), It.IsAny <string>()))
.Returns(Task.FromResult(apartment));
Mock <RequestRepository> mockRequestRepository = new Mock <RequestRepository>();
mockRequestRepository
.Setup(ur => ur.GetByValues(It.IsAny <int>(), It.IsAny <int>()))
.Returns(request);
Mock <IUnitOfWork> mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork
.Setup(u => u.GetRepository <User, UserRepository>())
.Returns(mockUserRepository.Object);
mockUnitOfWork
.Setup(u => u.GetRepository <Apartment, ApartmentRepository>())
.Returns(mockApartmentRepository.Object);
mockUnitOfWork
.Setup(u => u.GetRepository <Request, RequestRepository>())
.Returns(mockRequestRepository.Object);
RequestsController controller = new RequestsController(mockUnitOfWork.Object);
// Act
IActionResult result = await controller.DeleteRequest(user.Id, apartment.Id);
// Assert
Assert.NotNull(result);
Assert.IsType <OkResult>(result);
}
public void Index_ViewResult()
{
// Arrange
int userId = 1;
IEnumerable <Request> requests = new List <Request>
{
new Request {
Id = 5
}
};
Mock <RequestRepository> mockRequestRepository = new Mock <RequestRepository>();
mockRequestRepository
.Setup(rr => rr.GetShortInfo(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(requests);
Mock <IUnitOfWork> mockIUnitOfWork = new Mock <IUnitOfWork>();
mockIUnitOfWork
.Setup(u => u.GetRepository <Request, RequestRepository>())
.Returns(mockRequestRepository.Object);
RequestsController controller = new RequestsController(mockIUnitOfWork.Object);
Mock <ClaimsPrincipal> mockManager = new Mock <ClaimsPrincipal>();
mockManager
.Setup(p => p.FindFirst(It.IsAny <string>()))
.Returns(new Claim(nameof(User.Id), userId.ToString()));
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext()
{
User = mockManager.Object
}
};
// Act
IActionResult result = controller.Index();
// Assert
Assert.NotNull(result);
ViewResult viewResult = Assert.IsType <ViewResult>(result);
Assert.NotNull(viewResult.Model);
IndexViewModel indexViewModel = Assert.IsType <IndexViewModel>(viewResult.Model);
Assert.Equal(requests, indexViewModel.Requests);
Assert.Null(viewResult.ViewName);
}
public async Task WhenGetIncomingRequestsGetCalled()
{
Setup();
var fixture = new Fixture();
_expectedRequests = fixture.CreateMany <Request>().ToList();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestsRepository.Setup(repo => repo.GetRequestsByReceiverId(It.IsAny <Guid>())).ReturnsAsync(_expectedRequests);
_result = await RequestsController.GetIncomingRequests(_userId);
}
public void RequestsControllerUpdateTest()
{
var type = CreateContext();
var additionalField = CreateFieldLogicWithRanges(type);
var RequestId = Guid.NewGuid();
var Logic = CreateLogic();
var Controller = new RequestsController(Logic);
AdditionalFieldValue fieldRangeValue = new AdditionalFieldValue()
{
Id = Guid.NewGuid(),
AdditionalFieldId = additionalField.Id,
RequestId = RequestId
};
var selectedValue = new SelectedValues();
selectedValue.Value = "01/15/1993";
var values = new List <SelectedValues>()
{
selectedValue
};
fieldRangeValue.Values = values;
var valuesList = new List <AdditionalFieldValue>()
{
fieldRangeValue
};
Request Request = new Request()
{
Id = RequestId,
RequestorsName = "Just Testing",
RequestorsEmail = "*****@*****.**",
RequestorsPhone = "489498948894",
TypeId = type.Id,
AdditionalFieldValues = valuesList
};
Logic.Create(Request);
Request.State = "En Revision";
var result = Controller.Put(RequestId, RequestDTO.ToModel(Request));
var createdResult = result as CreatedAtRouteResult;
var model = createdResult.Value as RequestDTO;
Assert.AreEqual("En Revision", model.State);
}
public async void AcceptRequest_OkResult()
{
// Arrange
int requestId = 1;
IEnumerable <Request> requests = new List <Request>
{
new Request {
Id = 5, Apartment = new Apartment {
Renter = new User {
Id = 1
}
}
}
};
Mock <RequestRepository> mockRequestRepository = new Mock <RequestRepository>(MockBehavior.Loose);
mockRequestRepository
.Setup(rr => rr.Get(It.IsAny <Expression <Func <Request, bool> > >(),
null,
It.IsAny <string>(),
null, null))
.Returns(requests);
mockRequestRepository
.Setup(rr => rr.Delete(It.IsAny <Expression <Func <Request, bool> > >()));
Mock <GenericRepository <Notification> > mockNotificationRepository = new Mock <GenericRepository <Notification> >();
mockNotificationRepository
.Setup(n => n.InsertAsync(It.IsAny <Notification>()))
.Returns(System.Threading.Tasks.Task.FromResult(null as Notification));
Mock <IUnitOfWork> mockIUnitOfWork = new Mock <IUnitOfWork>();
mockIUnitOfWork
.Setup(u => u.GetRepository <Request, RequestRepository>())
.Returns(mockRequestRepository.Object);
mockIUnitOfWork
.Setup(u => u.GetRepository <Notification, GenericRepository <Notification> >())
.Returns(mockNotificationRepository.Object);
RequestsController controller = new RequestsController(mockIUnitOfWork.Object);
// Act
IActionResult result = await controller.AcceptRequest(requestId);
// Assert
Assert.NotNull(result);
Assert.IsType <OkResult>(result);
}
public void Setup()
{
_repository = new Mock <IRepository <Town> >();
_unitOfWork = new UnitOfWork();
_controller = new RequestsController(_unitOfWork);
_repository.Setup(x => x.GetAllAsync().Result)
.Returns(new List <Town>
{
new Town {
TownId = 1, TownName = "Kharkov"
}
});
}
public static async Task Returns_404_response_when_given_user_to_update_does_not_exist()
{
var controller = new RequestsController(
Mock.Of <IDateCalculator>(),
Mock.Of <IRequestRepository>(),
Mock.Of <ITriggerRepository>(),
CreateUserRepository.WithUserExists(UserId, false));
var result = await controller.PatchByIdAsync(
UserId,
new RequestsPatchRequest(Enumerable.Empty <RequestsPatchRequestDailyData>()));
Assert.IsType <NotFoundResult>(result);
}
public async Task WhenSendFriendRequestGetsCalled()
{
Setup();
var fixture = new Fixture();
_requestRequest = fixture.Create <RequestRequest>();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestValidator.Setup(validator => validator.ValidateNewRequest(It.IsAny <Request>()))
.ReturnsAsync(new List <Error>());
_result = await RequestsController.SendRequest(_requestRequest);
}
public void LoadShiftRequestsTest()
{
RequestsController rc = new RequestsController();
UserController uc = new UserController();
MySqlConnection connection = CreateConnection();
List <ShiftRequest> expectedRequests = rc.LoadShiftRequests();
uc.AddNewUser("Test", "Test", new DateTime(1998, 02, 04), "Eindhoven", Gender.MALE + 1, "12345678", new DateTime(2020, 02, 03),
"test", "test", "*****@*****.**", 1000, Role.EMPLOYEE + 1, 1, Department.Accessories.ToString());
using (connection)
{
connection.Open();
string sql = "INSERT INTO shift_requests(shift_id, user_id, work)" +
" VALUES (@shiftID, @userID, @work);";
using (MySqlCommand cmd = new MySqlCommand(sql, connection))
{
cmd.Parameters.AddWithValue("@shiftID", 1);
cmd.Parameters.AddWithValue("@userID", uc.lastInsertedUserId);
cmd.Parameters.AddWithValue("@work", 1);
cmd.ExecuteNonQuery();
}
connection.Close();
}
List <ShiftRequest> actualRequests = rc.LoadShiftRequests();
using (connection)
{
connection.Open();
string sql1 = "DELETE FROM shift_requests WHERE user_id = @id;";
using (MySqlCommand cmd = new MySqlCommand(sql1, connection))
{
cmd.Parameters.AddWithValue("@id", uc.lastInsertedUserId);
cmd.ExecuteNonQuery();
}
string sql2 = "DELETE FROM users WHERE username = @username;";
using (MySqlCommand cmd = new MySqlCommand(sql2, connection))
{
cmd.Parameters.AddWithValue("@username", "test");
cmd.ExecuteNonQuery();
}
connection.Close();
}
Assert.AreEqual(expectedRequests.Count + 1, actualRequests.Count);
}
public async Task SaveToDatabaseSendsCorrectMessageOnSuccess()
{
// Arrange
RequestsController controller = new RequestsController(_service);
// Act
IHttpActionResult actionResult = await controller.SaveDbRecordsToFile();
var contentResult = actionResult as OkNegotiatedContentResult <string>;
// Assert
Assert.NotNull(contentResult);
Assert.NotNull(contentResult.Content);
Assert.Equal(contentResult.Content, SuccessMessage.SavedToXml);
}
