internal void CreateCharacter(int characterId, Vector3 position, Vector3 rotation, bool isMainPlayer = false, int skillId = -1)
{
CreateCharacterCommand cmd = CommandManager.Instance.CreateCommand("createcharacter") as CreateCharacterCommand;
cmd.Load(characterId, position, rotation, isMainPlayer, skillId);
cmd.Execute(m_Instance, m_DeltaTime);
}
public void Handle_checkIfItemToInsertIsNotNull()
{
//Assert
var iconfMoq = new Mock <IConfiguration>().Object;
var command = new CreateCharacterCommand()
{
Item = new ApplicationLayer.CharacterList.Query.GetCharacters.CharacterItemDTO()
{
Name = "Luke Skywalker",
Episodes = new List <string> {
"NEWHOPE", "EPIRE"
},
Friends = new List <string> {
"Han Solo", "R2-D2"
}
}
};
//ACT - add and read it in the next step - see if item was added
var handler = new CreateCharacterCommand.CreateCharacterCommandHandler(iconfMoq);
var result = handler.Handle(command, CancellationToken.None);
Assert.NotNull(command.Item);
}
public Option <SuccessResult, ErrorResult> Create(CreateCharacterCommand command)
{
return(_createCharacterCommandValidator
.Validate(command)
.OnSuccess(errorBuilder =>
{
_characterRepository.Insert(_mapper.Map(command));
}));
}
public CharacterEntity Map(CreateCharacterCommand source)
{
var destination = new CharacterEntity
{
Name = source.Name,
Description = source.Description
};
return(destination);
}
public CharacterEntity Map(CreateCharacterCommand source)
{
var destination = new CharacterEntity
{
ProjectId = source.ProjectId,
AccountId = source.Credentials.AccountId,
Name = source.Name,
Description = source.Description
};
return(destination);
}
public async Task InvalidName_ValidationException(int nameLength)
{
var name = new string('x', nameLength);
var command = new CreateCharacterCommand {
Name = name
};
var validator = new CreateCharacterCommandValidator();
var result = await validator.ValidateAsync(command);
Assert.NotNull(result);
Assert.False(result.IsValid);
}
public async Task <ApiResponse <object> > Create(CreateCharacterDto request)
{
var command = new CreateCharacterCommand
{
Name = request.Name,
Class = request.Class
};
await _operationMediator.HandleAsync(command);
var location = Url.Link(GetByIdRouteName, new { id = command.GeneratedId });
return(ApiResponse.Created(location, command.GeneratedId));
}
public async Task WithSameNameExist_Exception()
{
var command = new CreateCharacterCommand {
Name = _alreadyExistingName
};
Task Act() => _handler.Handle(command, CancellationToken.None);
var ex = await Record.ExceptionAsync(Act) as EntityAlreadyExistsException <Character>;
Assert.NotNull(ex);
Assert.Equal(nameof(command.Name), ex.ConflictingPropertyName);
Assert.Equal(_alreadyExistingName, ex.ConflictingPropertyValue);
}
public async Task Ok()
{
const string name = "Alex";
var command = new CreateCharacterCommand {
Name = name
};
var result = await _handler.Handle(command, CancellationToken.None);
Assert.NotNull(result);
Assert.StrictEqual(_addedCharacter, result);
Assert.Equal(name, result.Name);
Assert.Null(result.CurrentLocation);
}
public StatusCodeResult Create([FromBody] JsonElement item)
{
var command = new CreateCharacterCommand();
command.Item = JsonConvert.DeserializeObject <CharacterItemDTO>(item.GetRawText());
var result = _mediator.Send(command).Result;
if (!result)
{
//not created, character already exists
return(new StatusCodeResult(409));
}
//everything ok
return(new StatusCodeResult(201));
}
public void CanExecuteCommand(string tListName, string tName)
{
var vDocumentStore = GetEmbeddedDatabase;
AddAccountToDataStore(vDocumentStore, cUserName, "ABC", "*****@*****.**");
var vModel = new CreateCharacterModel
{
GameName = cGameName,
Name = tName,
};
var vCommand = new CreateCharacterCommand(vDocumentStore, vModel, cUserName);
Assert.AreEqual(eCharacterCreationStatus.Success, vCommand.Execute());
}
public async Task Create_character_command_validator_should_pass()
{
// Arrange
var episode = new EpisodeBuilder().Generate().SaveChanges(_testFixture.Context).Build().First();
var command = new CreateCharacterCommand
{
EpisodesIds = new[] { episode.Id }, Name = "Han Solo", FriendsIds = new int[] { }
};
var validator = new CreateCharacterCommandValidator(_testFixture.Context);
// Act
var validationResult = await validator.ValidateAsync(command);
// Assert
validationResult.Errors.ShouldBeEmpty();
}
public async Task Create_character_command_validator_should_return_no_episodes_validation_error()
{
// Arrange
var episode = new EpisodeBuilder().Generate().SaveChanges(_testFixture.Context).Build().First();
var command = new CreateCharacterCommand
{
EpisodesIds = new[] { episode.Id + 1 }, Name = "Han Solo", FriendsIds = new int[] { }
};
var validator = new CreateCharacterCommandValidator(_testFixture.Context);
// Act
var validationResult = await validator.ValidateAsync(command);
// Assert
validationResult.Errors.Count.ShouldBe(1);
validationResult.Errors.First().ErrorCode.ShouldBe("PredicateValidator");
validationResult.Errors.First().ErrorMessage.ShouldBe("Character has to star in at least one episode");
}
public async Task <IActionResult> Post([FromBody] CreateCharacterCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await Mediator.Send(command);
return(CreatedAtAction(nameof(Get), new { id = result.Id }, result));
}
catch (Exception)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public async Task Create_character_command_validator_should_return_unique_name_validation_error()
{
// Arrange
var episode = new EpisodeBuilder().Generate().SaveChanges(_testFixture.Context).Build().First();
var character = new CharacterBuilder().Generate().SaveChanges(_testFixture.Context).Build().First();
var command = new CreateCharacterCommand
{
EpisodesIds = new[] { episode.Id }, Name = character.Name, FriendsIds = new int[] { }
};
var validator = new CreateCharacterCommandValidator(_testFixture.Context);
// Act
var validationResult = await validator.ValidateAsync(command);
// Assert
validationResult.Errors.Count.ShouldBe(1);
validationResult.Errors.First().ErrorCode.ShouldBe("PredicateValidator");
validationResult.Errors.First().ErrorMessage.ShouldBe("The character name has to be unique");
}
public void GetAllCharactersForAccountWorksToGetOne(string tName, string tListName)
{
var vDocumentStore = GetEmbeddedDatabase;
AddAccountToDataStore(vDocumentStore, cAccountName, "ABC", "*****@*****.**");
var vModel = new CreateCharacterModel
{
GameName = cGameName,
Name = tName,
};
var vCommand = new CreateCharacterCommand(vDocumentStore, vModel, cAccountName);
vCommand.Execute();
var vQuery = new GetAllCharactersForAccountQuery(vDocumentStore, cGameName, cAccountName);
var vResults = vQuery.Result;
Assert.AreEqual(1, vResults.Count);
}
public async Task <GenericCommandResponse> Create([FromBody] CreateCharacterCommand command, [FromServices] CharacterHandler handler)
{
return((GenericCommandResponse)await handler.Handle(command));
}
public async Task <ActionResult <int> > Create([FromBody] CreateCharacterCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public Task Handle(CreateCharacterCommand message, IMessageHandlerContext context) => Task.FromResult(_charactersService.AddCharacter(message));
public async Task <IActionResult> Add([FromBody] CreateCharacterCommand command)
{
await _messageSession.Send(command).ConfigureAwait(false);
return(Accepted());
}
public Task AddCharacter(CreateCharacterCommand command) => _characterRepository.AddCharacter(command.Name, command.Planet);
public void CharacterIsInDatabase(string tListName, string tName)
{
var vDocumentStore = GetEmbeddedDatabase;
AddAccountToDataStore(vDocumentStore, cUserName, "ABC", "*****@*****.**");
var vModel = new CreateCharacterModel
{
GameName = cGameName,
Name = tName,
};
var vCommand = new CreateCharacterCommand(vDocumentStore, vModel, cUserName);
Assert.AreEqual(eCharacterCreationStatus.Success, vCommand.Execute());
using (var vSession = vDocumentStore.OpenSession())
{
Assert.IsNotNull(
vSession.Load<Character>(cGameName + "/Characters/" + cUserName + "/" + tName));
}
}
