public async Task ShouldDeleteShooterBeOkHavingDeletedElement()
{
//Recupero una Shooter esistente non utilizzato
var existing = Scenario.Shooters.FirstOrDefault();
if (existing == null)
{
Assert.Inconclusive("Shooter does not exists");
}
//Conteggio gli elementi prima della cancellazione
var countBefore = Scenario.Shooters.Count;
//Composizione della request
var request = new ShooterRequest {
ShooterId = existing.Id
};
//Invoke del metodo
var response = await Controller.DeleteShooter(request);
//Parsing della risposta
var parsed = ParseExpectedOk <ShooterContract>(response);
//Conteggio gli elementi dopo la cancellazione
var countAfter = Scenario.Shooters.Count;
Assert.IsTrue(
parsed.Data.ShooterId == existing.Id);
Assert.AreEqual(countBefore - 1, countAfter);
}
public async Task ShouldFetchShooterAssociationInfoBeOkHavingProvidedData()
{
var existing = Scenario.ShooterAssociationInfos.FirstOrDefault();
if (existing == null)
{
Assert.Inconclusive("No shooter association exists");
}
var count = Scenario.ShooterAssociationInfos.Count(x => x.ShooterId == existing.ShooterId);
var request = new ShooterRequest
{
ShooterId = existing.ShooterId
};
//Invoke del metodo
var response = await Controller.FetchShooterAssociationInfo(request);
//Parsing della risposta e assert
var parsed = ParseExpectedOk <IList <ShooterAssociationInfoContract> >(response);
Assert.AreEqual(count, parsed.Data.Count);
Assert.IsTrue(parsed.Data.All(x => !string.IsNullOrEmpty(x.Association.Name)));
}
public Task <IActionResult> FetchShooterTeamByShooter(ShooterRequest request)
{
//Recupero l'elemento dal business layer
var entities = BasicLayer.FetchTeamsFromShooterId(request.ShooterId);
var teamIds = entities.Select(x => x.TeamId).ToList();
var teams = BasicLayer.FetchTeamsByIds(teamIds);
//Return contract
return(Reply(entities.As(x => ContractUtils.GenerateContract(x, teams.FirstOrDefault(t => t.Id == x.TeamId)))));
}
public Task <IActionResult> FetchAssociationsNotAssignedForShooter(ShooterRequest request)
{
var associationIds = BasicLayer.FetchAllShooterAssociationInfos(request.ShooterId)
.Select(x => x.AssociationId)
.ToList();
//Recupero la lista dal layer
var entities = BasicLayer.FetchAllAssociations();
//Ritorno i contratti
return(Reply(entities.Where(x => !associationIds.Contains(x.Id)).As(ContractUtils.GenerateContract)));
}
public Task <IActionResult> FetchAvailableAssociationsForShooter(ShooterRequest request)
{
var associationIds = BasicLayer.FetchAllShooterAssociationInfos(request.ShooterId)
.Select(x => x.AssociationId)
.ToList();
//Recupero la lista dal layer
var entities = BasicLayer.FetchAssociationsByIds(associationIds);
//Ritorno i contratti
return(Reply(entities.As(x => ContractUtils.GenerateContract(x))));
}
public Task <IActionResult> GetShooter(ShooterRequest request)
{
var entity = BasicLayer.GetShooter(request.ShooterId);
//verifico validità dell'entità
if (entity == null)
{
return(Task.FromResult <IActionResult>(NotFound()));
}
//Serializzazione e conferma
return(Reply(ContractUtils.GenerateContract(entity)));
}
public async Task ShouldGetShooterBeOkHavingProvidedData()
{
//Recupero una Shooter esistente
var existing = Scenario.Shooters.FirstOrDefault();
if (existing == null)
{
Assert.Inconclusive("Shooter does not exists");
}
//conteggio esistenti
var countBefore = Scenario.Shooters.Count;
//Composizione della request
var request = new ShooterRequest
{
ShooterId = existing.Id
};
//Invoke del metodo
var response = await Controller.GetShooter(request);
//Parsing della risposta e assert
var parsed = ParseExpectedOk <ShooterContract>(response);
//conteggio esistenti
var countAfter = Scenario.Shooters.Count;
Assert.IsTrue(parsed != null &&
parsed.Data.Email == existing.Email &&
parsed.Data.LastName == existing.LastName &&
parsed.Data.FirstName == existing.FirstName &&
parsed.Data.BirthDate == existing.BirthDate &&
parsed.Data.FirearmsLicence == existing.FirearmsLicence &&
parsed.Data.FirearmsLicenceExpireDate == existing.FirearmsLicenceExpireDate &&
parsed.Data.MedicalExaminationExpireDate == existing.MedicalExaminationExpireDate &&
parsed.Data.Username == existing.Username);
//verifica contatori
Assert.AreEqual(countBefore, countAfter);
}
public async Task ShouldDeleteShooterBeOkAndDeletePermissions()
{
var permission =
Scenario.Permissions.FirstOrDefault(x => x.Name == nameof(Permissions.EditShooter));
if (permission == null)
{
Assert.Inconclusive("Permissions not found");
}
//Recupero una Shooter esistente non utilizzato
var existing = Scenario.Shooters.FirstOrDefault();
//var existing = Scenario.Shooters.FirstOrDefault(x => x.Id == permission.EntityId);
if (existing == null)
{
Assert.Inconclusive("Shooter does not exists");
}
//Composizione della request
var request = new ShooterRequest {
ShooterId = existing.Id
};
//Invoke del metodo
var response = await Controller.DeleteShooter(request);
//Parsing della risposta
var parsed = ParseExpectedOk <ShooterContract>(response);
//Conteggio gli elementi dopo la cancellazione
var countPermissionAfter = Scenario.Permissions.Count(x =>
//x.EntityId == permission.EntityId &&
x.Name == nameof(Permissions.EditShooter));
Assert.IsTrue(
parsed.Data.ShooterId == existing.Id);
//Assert.AreEqual(0, countPermissionAfter);
}
public async Task <IActionResult> DeleteShooter([EntityId] ShooterRequest request)
{
//Recupero l'elemento dal business layer
var entity = BasicLayer.GetShooter(request.ShooterId);
//Se l'utente non hai i permessi non posso rimuovere entità con userId nullo
if (entity == null)
{
return(NotFound());
}
//Invocazione del service layer
var validations = await BasicLayer.DeleteShooter(entity, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
//Return contract
return(Ok(ContractUtils.GenerateContract(entity)));
}
public Task <IActionResult> FetchShooterAssociationInfo(ShooterRequest request)
{
//Recupero l'elemento dal business layer
var entity = BasicLayer.GetShooter(request.ShooterId);
//modifica solo se admin o se utente richiedente è lo stesso che ha creato
if (entity == null)
{
return(Task.FromResult <IActionResult>(NotFound()));
}
;
//Invocazione del service layer
var shooterAssociations = BasicLayer.FetchShooterAssociationInfoByShooterId(entity.Id);
var associationIds = shooterAssociations.Select(x => x.AssociationId).ToList();
var associations = BasicLayer.FetchAssociationsByIds(associationIds);
//Return contract
return(Reply(
shooterAssociations.As(x => ContractUtils.GenerateContract(x, associations.FirstOrDefault(a => a.Id == x.AssociationId)))
.OrderBy(x => x.Association.Name).ToList()
));
}
public async Task ShouldDeleteShooterBeNotFoundHavingProvidedWrongId()
{
//Conteggio gli elementi prima della cancellazione
var countBefore = Scenario.Shooters.Count;
//Composizione della request
var request = new ShooterRequest {
ShooterId = RandomizationUtils.GenerateRandomString(10)
};
//Invoke del metodo
var response = await Controller.DeleteShooter(request);
//Parsing della risposta
var parsed = ParseExpectedNotFound(response);
//Conteggio gli elementi dopo la cancellazione
var countAfter = Scenario.Shooters.Count;
Assert.IsTrue(parsed != null &&
parsed.Data == null);
Assert.AreEqual(countBefore, countAfter);
}
