public async Task DeleteAsyncRequestCorrectlyTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
await SeedDataAsync(dbContext);
var request = requestRepository.All().FirstOrDefault();
await service.DeleteAsync(request.Id);
var result = service.AllRequests <RequestInfoViewModel>(null).Count();
Assert.Equal(0, result);
}
public async Task GetRequestByIdShouldReturnCorrectlyTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
await SeedDataAsync(dbContext);
var request = requestRepository.All().FirstOrDefault();
var result = service.GetById <RequestInfoViewModel>(request.Id);
Assert.NotNull(result);
}
public async Task AllRequestsShouldReturnNotNullTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
await SeedDataAsync(dbContext);
var result = service.AllRequests <RequestInfoViewModel>(null).Count();
Assert.Equal(1, result);
}
public async Task DeleteAsyncRequestThrowsExceptionTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
await SeedDataAsync(dbContext);
var request = requestRepository.All().FirstOrDefault();
await service.DeleteAsync(request.Id);
await Assert.ThrowsAsync <ArgumentException>(() => service.DeleteAsync(request.Id));
}
public async Task CreateRequestCorrectHospitalDataRequestEntityTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
await SeedDataAsync(dbContext);
var request = requestRepository
.All()
.Where(r => r.NeededQuantity == 500)
.FirstOrDefault();
var requestHospitalData = hospitalDataRequestRepository
.All()
.FirstOrDefault();
Assert.Equal(request.Id, requestHospitalData.RequestId);
}
public async Task WhenAcceptRequestGetsCalled()
{
Setup();
_request = new Fixture().Build <Request>().With(request => request.RequestType, RequestType.Friend).Create();
await RequestsService.AcceptRequest(_request);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AcceptRequest_Click(object sender, RoutedEventArgs e)
{
var request = datagrid.SelectedItem as Request.Request;
RequestsService.ChangeRequestsStatus(request, State.Accepted);
NotificationService.AddNotification(request, "Администратор принял вашу заявку");
}
public async Task CreateRequestShouldReturnNotNullTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
// Seeding user
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
};
dbContext.Users.Add(user);
// Seeding hospital
var hospital = new HospitalData
{
ApplicationUserId = user.Id,
Name = "HospitalName",
Contact = new Contact
{
Phone = "123456789",
Email = "*****@*****.**",
},
Location = new Location
{
Country = "Bulgaria",
City = "Sofia",
AdressDescription = "Sofia",
},
};
dbContext.HospitalData.Add(hospital);
await dbContext.SaveChangesAsync();
await service.CreateRequestAsync(hospital.ApplicationUserId, "...", DateTime.UtcNow, EmergencyStatus.WithinDay, BloodGroup.A, RhesusFactor.Negative, 500);
var result = requestRepository
.All()
.Where(r => r.NeededQuantity == 500)
.FirstOrDefault();
Assert.NotNull(result);
}
private void CreateTestPlayerAt(Vector2 position)
{
RequestsService.CreateRequestEntity()
.AddGenerateCharacterRequest(
position,
Faction.Player,
CharacterType.goblin
);
}
private void CreateTestEnemyAt(Vector2 position)
{
RequestsService.CreateRequestEntity()
.AddGenerateCharacterRequest(
position,
Faction.Enemy,
CharacterType.knight
);
}
public static void Start(String in_address, int in_port, int in_max)
{
if (m_server == null)
{
// Creates a TCP server to execute client requests asynchronously.
m_provider = new RequestsService();
m_server = new Server(m_provider, in_port, in_max);
m_server.Start(in_address);
}
}
public async Task WhenIsRequestAlreadySentGetsCalled()
{
Setup();
_request = new Fixture().Create <Request>();
RequestsRepository.Setup(repository => repository.GetRequestByUserIdsAndType(It.IsAny <Request>()))
.ReturnsAsync(_request).Callback <Request>(req => _usedRequest = req);
_result = await RequestsService.IsRequestAlreadySent(_request);
}
protected override void Execute(List <InputEntity> entities)
{
foreach (InputEntity entity in entities)
{
RequestsService.CreateRequestEntity()
.AddEnergyRequireingRequest(
() => CreateBeacon(entity),
null,
gameContext.gameStateEntity.beaconCost.Value
);
}
}
public async Task CreateRequestShouldThrowExceptionIfInvalidDataIsPassTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
// Seeding user
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
};
dbContext.Users.Add(user);
// Seeding hospital
var hospital = new HospitalData
{
ApplicationUserId = user.Id,
Name = "HospitalName",
Contact = new Contact
{
Phone = "123456789",
Email = "*****@*****.**",
},
Location = new Location
{
Country = "Bulgaria",
City = "Sofia",
AdressDescription = "Sofia",
},
};
dbContext.HospitalData.Add(hospital);
await dbContext.SaveChangesAsync();
await Assert.ThrowsAsync <ArgumentException>(() => service.CreateRequestAsync(hospital.ApplicationUserId, "content...", DateTime.UtcNow, EmergencyStatus.WithinDay, BloodGroup.A, RhesusFactor.Negative, 0));
}
public void Reload()
{
var service = new RequestsService();
Requests.Clear();
var list = service.Get().ToList();
list.Reverse();
foreach (var x in list)
{
Requests.Add(x);
}
}
private void OnGoogleLoginButtonClicked(object sender, EventArgs e)
{
IRequestsService req;
req = new RequestsService();
OrdersService serv = new OrdersService(req);
var t = serv.GetPersonsAsync();
// Display the activity handling the authentication
var authenticator = Auth.GetAuthenticator();
var intent = authenticator.GetUI(this);
StartActivity(intent);
}
public async Task CreateRequestShouldthrowExceptionDueToNullHospitalDataTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
await Assert.ThrowsAsync <ArgumentException>(() => service.CreateRequestAsync("1", "...", DateTime.UtcNow, EmergencyStatus.WithinDay, BloodGroup.A, RhesusFactor.Negative, 500));
}
public void GetRequestByIdShouldThrowErrorTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
Assert.Throws <ArgumentException>(() => service.GetById <RequestInfoViewModel>(null));
}
public async Task WhenValidateNewRequestsGetsCalled()
{
Setup();
_expectedErrors = new List <Error>
{
new Error("invalid_request", "A user cannot send themselves a request."),
new Error("invalid_request", "You are already connected."),
new Error("invalid_request", "The request has already been sent.")
};
_request = new Fixture().Build <Request>().With(request => request.RequestType, RequestType.Friend)
.Create();
_request.ReceiverId = _request.SenderId;
RelationshipsService.Setup(service => service.AreAlreadyFriends(It.IsAny <Guid>(), It.IsAny <Guid>()))
.ReturnsAsync(true);
RequestsService.Setup(service => service.IsRequestAlreadySent(It.IsAny <Request>())).ReturnsAsync(true);
_result = await RequestValidator.ValidateNewRequest(_request);
}
public void CreateRequestNullTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
var result = requestRepository.All().FirstOrDefault();
Assert.Null(result);
}
public void Execute()
{
RequestsService.CreateRequestEntity().AddSwitchBeaconActionRequest(Action);
}
public RequestController(RequestsService service, IMapper mapper)
{
_service = service;
_mapper = mapper;
}
private void SetDefaultsToGameSettings()
{
BeaconAction currentBeaconAction = gameContext.settingsEntity.globalSettings.Value.DefaultBeaconAction;
RequestsService.CreateRequestEntity().AddSwitchBeaconActionRequest(currentBeaconAction);
}
public void ThenRequestServiceAcceptRequestShouldHaveBeenCalled() => RequestsService.Verify(service => service.AcceptRequest(It.IsAny <Request>()), Times.Once);
public void ThenRequestServiceDeclineRequestShouldNotHaveBeenCalled() => RequestsService.Verify(service => service.DeclineRequest(It.IsAny <Request>()), Times.Never);
public AuthController(RequestsService service)
{
_service = service;
}
public void ThenRequestServiceIsRequestAlreadySentShouldHaveBeenCalled() => RequestsService.Verify(service => service.IsRequestAlreadySent(It.IsAny <Request>()), Times.Once);
public HasteBinHandler(RequestsService request)
{
_request = request;
}
