public async Task CharacterService_Update_Success(Character character)
{
MockDbCharacter_Success(character);
var characterRequest = new CharacterRequest()
{
Name = character.Name,
Patronus = character.Patronus,
Role = character.Role,
School = character.School,
House = character.House?.Id
};
MockCheckHouseInconsistencies_Success(characterRequest, character.Id);
var insertResult = await _characterService.UpdateAsync(characterRequest);
Assert.True(insertResult.Success);
_characterRepositoryMock.Verify(x =>
x.UpdateAsync(
It.Is <Character>(y =>
y.Id == character.Id &&
y.Name == character.Name &&
y.Patronus == character.Patronus &&
(character.House != null ? y.House.Id == character.House.Id : y.House == null) &&
y.Role == character.Role &&
y.School == character.School
),
It.IsAny <System.Threading.CancellationToken>()
),
Times.Once()
);
}
public static Character From(CharacterRequest characterRequest)
{
var character = new Character();
character.Name = characterRequest.Name;
return(character);
}
public async Task CharacterService_Update_HouseInconsistencies_NotSuccess()
{
var house = new House("id", "name", "mascot", "hof", "hog", "founder");
var character = new Character(
"id",
"name",
null,
null,
house,
null,
new System.DateTime(),
new System.DateTime());
var characterRequest = new CharacterRequest()
{
Name = character.Name,
Patronus = character.Patronus,
House = character.House.Id,
Role = character.Role,
School = character.School
};
MockDbCharacter_Success(character);
MockCheckHouseInconsistencies_NotSuccess();
var updateResult = await _characterService.UpdateAsync(characterRequest);
Assert.False(updateResult.Success);
}
public async Task HouseService_CheckHouseInconsistenciesCharacterNotPartOfHouse_NotSuccess()
{
var characterId = "characterId";
var houseId = "houseId";
PotterApiHouse house = new PotterApiHouse()
{
_id = houseId,
founder = "founder",
name = "name",
members = new string[] { }
};
List <PotterApiHouse> potterApiHouses = new List <PotterApiHouse>()
{
house
};
_potterApiHouseServiceMock.Setup(x => x.GetAllAsync()).Returns(Task.FromResult(potterApiHouses));
var character = new CharacterRequest()
{
Name = "name",
Patronus = "pat",
House = houseId,
Role = "role",
School = "scho"
};
var insertResult = await _houseService.CheckHouseInconsistenciesAsync(character, characterId);
Assert.False(insertResult.Success);
Assert.Single(insertResult.Messages);
Assert.Contains(insertResult.Messages, x => x == string.Format(HouseMessages.CharacterNotPartOfHouse, character.Name, house.name));
}
public CharacterRequest GetCharacterCustomisationData()
{
CharacterRequest characterRequest = new CharacterRequest();
characterRequest.name = characterNameInput.text;
return(characterRequest);
}
public CharacterResponse Get()
{
var request = new CharacterRequest {
CharacterId = characterService.DefaultID, MotionName = characterService.DefaultMotionName
};
return(GetCharacter(request));
}
public CharacterResponse GetCharacter(CharacterRequest request)
{
var collection = characterService.GetCharacter(request.CharacterId, request.MotionName);
return(new CharacterResponse
{
CharacterCollection = collection
});
}
public override Task <CharacterResponse> GetCharacter(CharacterRequest request, ServerCallContext context)
{
var character = Characters.FirstOrDefault(i => i.Id == request.Id);
return(Task.FromResult(new CharacterResponse {
Character = character
}));
// return base.GetCharacter(request, context);
}
public void HandleCharacterSaveButton()
{
CharacterRequest characterRequest = characterScreen.GetCharacterCustomisationData();
if (string.IsNullOrEmpty(characterRequest.name))
{
characterScreen.DisplayErrorMessage("Name cannot be empty!");
}
loginManager.LoginServerClient.SaveCharacter(characterRequest, HandleCharacterCreateResponse);
}
/// <summary>
/// CentCom call to store a new character for the current user.
/// Requires Authenticate to have been called at least once before.
/// </summary>
/// <param name="characterRequest"></param>
/// <param name="resultCallback"></param>
public void SaveCharacter(CharacterRequest characterRequest, Action <string, bool> resultCallback)
{
ValidateToken("Save Character");
monoBehaviour.StartCoroutine(HandlePayloadRequest(
UnityWebRequest.kHttpVerbPOST,
connectionAddress + Post_CreateCharacter,
JsonUtility.ToJson(characterRequest),
"Save Character",
true,
resultCallback
));
}
public bool Update(CharacterRequest characterRequest)
{
if (!ValidateRequest(characterRequest))
{
return(false);
}
var character = new Character(characterRequest.Id, characterRequest.Name, characterRequest.Role, characterRequest.School, characterRequest.House, characterRequest.Patronus);
_repository.Update(character);
return(_unitOfWork.Commit());
}
public IActionResult Create([FromBody] CharacterRequest request)
{
var character = Character.From(request);
long userId = Int64.Parse(User.Identity.Name);
try
{
_characterService.Create(character, userId);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ActionResult <CharacterResponse> > Post([FromBody] CharacterRequest request)
{
try
{
var command = request.ToCommand();
var view = await _applicationService.CreateCharacterAsync(command);
return(new CharacterResponse(view));
}
catch (Exception e)
{
_logger.LogError(e, "Unhandled exception in /characters POST");
return(StatusCode(500, new ErrorResponse(e)));
}
}
private void MockCheckHouseInconsistencies_Success(CharacterRequest character, string id)
{
DefaultResult <House> houseResponse = new DefaultResult <House>();
if (string.IsNullOrEmpty(character.House))
{
houseResponse.SetData(null);
}
else
{
houseResponse.SetData(new House(character.House, null, null, null, null, null));
}
_houseServiceMock.Setup(x => x.CheckHouseInconsistenciesAsync(character, id)).Returns(Task.FromResult(houseResponse));
}
public int Insert(CharacterRequest characterRequest)
{
if (!ValidateRequest(characterRequest))
{
return(characterRequest.Id);
}
var character = new Character(0, characterRequest.Name, characterRequest.Role, characterRequest.School, characterRequest.House, characterRequest.Patronus);
_repository.Insert(character);
_unitOfWork.Commit();
return(character.Id);
}
public void UpdateCharacter__WithNullRequest()
{
#region Arrange
var controller = new StarsWarsController(_starsWarsManager);
CharacterRequest request = null;
#endregion
#region Act
var response = controller.UpdateCharacter(request);
#endregion
#region Assert
Assert.IsInstanceOfType(response, typeof(BadRequestErrorMessageResult));
#endregion
}
public IHttpActionResult CreateCharacter(CharacterRequest request)
{
try
{
_log.Info("begin CreateCharacter");
if (request == null)
{
throw new ArgumentNullException("The request content was null or not in the correct format");
}
_starsWarsManager.CreateCharacter(Mapper.Map <Character>(request));
return(Content <CharacterResponse>(HttpStatusCode.Created, new CharacterResponse()
{
Data = request
}));
}
catch (ArgumentNullException argEx)
{
_log.Error(argEx);
return(BadRequest(argEx.Message));
}
catch (EntityNotFoundException enEx)
{
_log.Error(enEx);
return(Content <CharacterResponse>(HttpStatusCode.NotFound, new CharacterResponse()
{
Message = enEx.Message
}));
}
catch (StarsWarsException swEx)
{
_log.Error(swEx);
return(Content <CharacterResponse>((HttpStatusCode)422, new CharacterResponse()
{
Message = swEx.Message
}));
}
catch (Exception ex)
{
_log.Error(ex);
return(Content <CharacterResponse>(HttpStatusCode.InternalServerError, new CharacterResponse()
{
Message = ex.Message
}));
}
}
private async Task PutCharacterTest(CharacterRequest characterRequest)
{
_outputHelper.WriteLine("Executando Put");
var putResponse = await _httpClient.PutAsJsonAsync <CharacterRequest>($"/api/v1/Characters", characterRequest);
var jsonString = await putResponse.Content.ReadAsStringAsync();
var putResponseJson = JsonConvert.DeserializeObject <DefaultResult_CharacterResponse>(jsonString);
Assert.True(putResponseJson.Success);
Assert.Equal(characterRequest.Name, putResponseJson.Data.Name);
Assert.Equal(characterRequest.Role, putResponseJson.Data.Role);
Assert.Equal(characterRequest.School, putResponseJson.Data.School);
Assert.Equal(characterRequest.House, putResponseJson.Data.House.Id);
Assert.Equal(HttpStatusCode.OK, putResponse.StatusCode);
}
private async Task GetCharacters(CharacterRequest characterRequest)
{
_outputHelper.WriteLine("Executando Get");
var getResponse = await _httpClient.GetAsync($"/api/v1/Characters?name={characterRequest.Name}");
var jsonString = await getResponse.Content.ReadAsStringAsync();
var getResponseJson = JsonConvert.DeserializeObject <DefaultResult_CharacterResponseList>(jsonString);
Assert.True(getResponseJson.Success);
Assert.Single(getResponseJson.Data);
Assert.Equal(characterRequest.Name, getResponseJson.Data.FirstOrDefault().Name);
Assert.Equal(characterRequest.Role, getResponseJson.Data.FirstOrDefault().Role);
Assert.Equal(characterRequest.School, getResponseJson.Data.FirstOrDefault().School);
Assert.Equal(characterRequest.House, getResponseJson.Data.FirstOrDefault().House.Id);
Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode);
}
public override Task <CharacterReply> GetCharacterInfo(CharacterRequest request, ServerCallContext context)
{
var storage = DummyStorageData.GetData();
var character = storage.Where(x => x.Id == request.Id).FirstOrDefault();;
var reply = new CharacterReply()
{
Id = character.Id,
Name = character.Name,
Height = character.Height,
Mass = character.Mass,
Gender = character.Gender
};
return(Task.FromResult(reply));
}
public async Task RunCrudTest()
{
var characterId = "5a0fa6bbae5bc100213c2334";
var myCharacter = new CharacterRequest()
{
Name = "Phineas Nigellus Black",
Role = "(Formerly) Headmaster of Hogwarts",
School = "Hogwarts School of Witchcraft and Wizardry"
};
await DeleteCharacterTest(characterId);
await PostCharacterTest(myCharacter);
myCharacter.House = "5a05dc8cd45bd0a11bd5e071";
await PutCharacterTest(myCharacter);
await GetCharacters(myCharacter);
}
public async Task CharacterService_Insert_HouseInconsistencies_NotSuccess()
{
var character = new CharacterRequest()
{
Name = "name",
Patronus = "pat",
House = "houseid",
Role = "role",
School = "scho"
};
MockPotterCharacter_Success(character);
MockCheckHouseInconsistencies_NotSuccess();
var insertResult = await _characterService.InsertAsync(character);
Assert.False(insertResult.Success);
}
public async Task <DefaultResult <CharacterResponse> > InsertAsync(CharacterRequest characterRequest)
{
var defaultResult = new DefaultResult <CharacterResponse>();
var characterInconsistenciesResult = await CheckInsertInconsistenciesAsync(characterRequest);
if (!characterInconsistenciesResult.Success)
{
defaultResult.SetMessages(characterInconsistenciesResult.Messages);
return(defaultResult);
}
var character = new Character(
characterInconsistenciesResult.Data.Id,
characterRequest.Name,
characterRequest.Role,
characterRequest.School,
characterInconsistenciesResult.Data.House,
characterRequest.Patronus,
DateTime.Now,
DateTime.Now);
var validatorResult = character.Validate();
if (!validatorResult.IsValid)
{
defaultResult.SetMessages(validatorResult.Errors.Select(x => x.ErrorMessage).ToList());
}
else
if ((await ExistsByName(character.Name)))
{
defaultResult.SetMessage(string.Format(CharacterMessages.ExistsInDatabase, character.Name));
}
if (defaultResult.Success)
{
await _characterRepository.InsertAsync(character);
defaultResult.SetData((CharacterResponse)character);
defaultResult.IsSuccess();
}
return(defaultResult);
}
public override async Task <CharacterResponse> GetCharacter(CharacterRequest request, ServerCallContext context)
{
try
{
var starwarsPerson = await _starwarsPersonService.GetPerson(request.Name);
return(new CharacterResponse
{
Name = starwarsPerson.Name,
Gender = starwarsPerson.Gender,
Height = starwarsPerson.Height
});
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(null);
}
public async Task CharacterService_Update_NotExistsInDatabase_NotSuccess()
{
var character = new CharacterRequest()
{
Name = "name",
Patronus = "pat",
House = "houseid",
Role = "role",
School = "scho"
};
MockDbCharacter_NotSuccess();
MockCheckHouseInconsistencies_NotSuccess();
var updateResult = await _characterService.UpdateAsync(character);
Assert.False(updateResult.Success);
Assert.Single(updateResult.Messages);
Assert.Contains(updateResult.Messages, x => x == string.Format(CharacterMessages.NotExistsNameInDatabase, character.Name));
}
public void CreateCharacter__WithGoodRequest()
{
#region Arrange
var controller = new StarsWarsController(_starsWarsManager);
CharacterRequest request = new CharacterRequest()
{
Name = "Chewbacca"
};
#endregion
#region Act
var response = controller.CreateCharacter(request) as NegotiatedContentResult <CharacterResponse>;
#endregion
#region Assert
Assert.IsNotNull(response);
Assert.IsNotNull(response.Content);
Assert.AreEqual(201, (int)response.StatusCode);
#endregion
}
public void CreateCharacter__DuplicatedRequest()
{
#region Arrange
var controller = new StarsWarsController(_starsWarsManager);
CharacterRequest request = new CharacterRequest()
{
Name = "Chewbacca"
};
#endregion
#region Act
var response = controller.CreateCharacter(request) as NegotiatedContentResult <CharacterResponse>;
#endregion
#region Assert
Assert.IsNotNull(response);
Assert.AreEqual($"Character {request.Name} already exists", response.Content.Message);
Assert.AreEqual(422, (int)response.StatusCode);
#endregion
}
public void UpdateCharacter__WithGoodRequest()
{
#region Arrange
var controller = new StarsWarsController(_starsWarsManager);
CharacterRequest request = new CharacterRequest()
{
Id = 13,
Name = "Beru Lars"
};
#endregion
#region Act
var response = controller.UpdateCharacter(request) as OkNegotiatedContentResult <CharacterResponse>;
#endregion
#region Assert
Assert.IsNotNull(response);
Assert.IsNotNull(response.Content);
#endregion
}
private PotterApiCharacter MockPotterCharacter_Success(CharacterRequest character)
{
var potterApiCharacter = new PotterApiCharacter()
{
_id = "charid",
name = character.Name,
patronus = character.Patronus,
house = character.House,
role = character.Role,
school = character.School
};
List <PotterApiCharacter> potterApiCharacterList = new List <PotterApiCharacter>()
{
potterApiCharacter
};
_potterApiCharacterServiceMock.Setup(x => x.GetByNameAsync(character.Name)).Returns(Task.FromResult(potterApiCharacterList));
return(potterApiCharacter);
}
public async Task CharacterService_Insert_NotExistsInPotterApi_NotSuccess()
{
var character = new CharacterRequest()
{
Name = "name",
Patronus = "pat",
House = "houseid",
Role = "role",
School = "scho"
};
MockPotterCharacter_NotSuccess();
MockCheckHouseInconsistencies_NotSuccess();
var insertResult = await _characterService.InsertAsync(character);
Assert.False(insertResult.Success);
Assert.NotEmpty(insertResult.Messages);
Assert.Single(insertResult.Messages);
Assert.Contains(insertResult.Messages, x => x == string.Format(CharacterMessages.NotExistsInPotterApi, character.Name));
}
