public void UpdateEnvironment_ShouldCallService_AndReturn200WithDtos_WhenEnvironmentFound()
{
var environmentDTO = new EnvironmentDTO()
{
Id = 1, Phase = "Teste"
};
var expectedReturnFromService = new Environment()
{
Id = 1, Phase = "Teste"
};
_serviceMock.Setup(x => x.RegisterOrUpdate(It.IsAny <Environment>())).Returns(expectedReturnFromService);
var result = _controller.UpdateEnvironment(environmentDTO);
_serviceMock.Verify(x => x.RegisterOrUpdate(It.IsAny <Environment>()), Times.Once);
var objectResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.Equal(200, objectResult.StatusCode);
var dto = Assert.IsType <EnvironmentDTO>(objectResult.Value);
Assert.Equal(expectedReturnFromService.Phase.ToLower(), dto.Phase);
}
public HttpResponseMessage ListMulticasts(EnvironmentDTO environmentDto)
{
_response.Content =
new StringContent(new ClientImagingServices().MulicastSessionList(environmentDto.environment),
Encoding.UTF8, "text/plain");
return(_response);
}
public ActionResult <EnvironmentDTO> PostEnvironment([FromBody] EnvironmentDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(base.Ok(_mapper.Map <EnvironmentDTO>(_service.CreateEnvironment(_mapper.Map <Environment>(value)))));
}
public ActionResult <EnvironmentDTO> PostEnvironment([FromBody] EnvironmentDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(_mapper.Map <EnvironmentDTO>(_service.RegisterOrUpdateEnvironment(_mapper.Map <Infra.Entidades.Environment>(value)))));
}
public static Domain.Environment TranslateDTOToDomain(this EnvironmentDTO environmentDTO)
{
return(new Domain.Environment
{
Host = environmentDTO.Host,
Name = environmentDTO.Name,
ValidateSSL = environmentDTO.ValidateSSL
});
}
public void Validation_ModelState_False()
{
var dto = new EnvironmentDTO();
var context = new ValidationContext(dto, null, null);
var results = new List <ValidationResult>();
var isModelStateValid = Validator.TryValidateObject(dto, context, results, true);
Assert.False(isModelStateValid);
}
public ActionResult <EnvironmentDTO> CreateEnvironment(EnvironmentDTO environment)
{
if (String.IsNullOrWhiteSpace(environment.Name))
{
return(BadRequest());
}
var entity = _mapper.Map <Environment>(environment);
_environmentRepository.Save(entity);
var EnvironmentDTO = _mapper.Map <EnvironmentDTO>(_environmentRepository.GetById(entity.Id));
return(Ok(_mapper.Map <EnvironmentDTO>(EnvironmentDTO)));
}
public ActionResult <EnvironmentDTO> SaveEnvironment([FromBody] EnvironmentDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else
{
return(Ok
(_mapper.Map <EnvironmentDTO>
(_service.RegisterOrUpdate
(_mapper.Map <Model.Models.Environment>(value)))));
}
}
public ActionResult Post([FromBody] EnvironmentDTO env)
{
try
{
if (env == null)
{
return(NotFound());
}
applicationServiceEnvironment.Add(env);
return(Ok("Environment Cadastrado com sucesso!"));
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Put([FromBody] EnvironmentDTO env)
{
try
{
if (env == null)
{
return(NotFound());
}
applicationServiceEnvironment.Update(env);
return(Ok("Environment Atualizado com sucesso!"));
}
catch (Exception)
{
throw;
}
}
public ActionResult Delete([FromBody] EnvironmentDTO env)
{
try
{
if (env == null)
{
return(NotFound());
}
applicationServiceEnvironment.Remove(env);
return(Ok("Environment Removido com sucesso!"));
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult <Object> Post([FromBody] EnvironmentDTO environmentDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var envFound = _repo.SelecionarPorNome(environmentDTO.Name);
if (envFound != null)
{
return(BadRequest(new { errors = new ArrayList()
{
new { Name = "Name '" + environmentDTO.Name + "' already exists!" }
} }));
}
_repo.Incluir(_mapper.Map <Environment>(environmentDTO));
return(Ok(new { success = "Environment '" + environmentDTO.Name + "' created!" }));
}
public void SaveEnvironment_ShouldCallService_AndReturn200_WhenEverythingGoesRight()
{
var dto = new EnvironmentDTO {
Phase = "Teste"
};
var level = new Environment {
Id = 1, Phase = "Teste"
};
_serviceMock.Setup(x => x.RegisterOrUpdate(It.IsAny <Environment>())).Returns(level);
var result = _controller.SaveEnvironment(dto);
var validation = _controller.ModelState.IsValid;
_serviceMock.Verify(x => x.RegisterOrUpdate(It.IsAny <Environment>()), Times.Once);
var objectResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.Equal(200, objectResult.StatusCode);
Assert.True(validation);
}
public ActionResult <Object> Delete([FromBody] EnvironmentDTO environmentDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var envFound = _repo.SelecionarPorNome(environmentDTO.Name);
if (envFound == null)
{
return(NotFound(new { message = "Name '" + environmentDTO.Name + "' not found!" }));
}
if (_repoLogs.SelecionarTodos().Where(x => x.IdEnvironment == envFound.Id).ToList().Count > 0)
{
return(BadRequest(new { errors = new ArrayList()
{
new { message = "You cannot delete this environment, there are logs linked to it! Delete all linked logs before deleting this environment." }
} }));
}
_repo.Excluir(envFound.Id);
return(Ok(new { success = "Environment '" + environmentDTO.Name + "' deleted!" }));
}
public void Add(EnvironmentDTO environmentDTO)
{
var environment = mapper.Map <Environment>(environmentDTO);
serviceEnvironment.Add(environment);
}
public void Remove(EnvironmentDTO environmentDTO)
{
var environment = mapper.Map <Environment>(environmentDTO);
serviceEnvironment.Remove(environment);
}
public void Update(EnvironmentDTO environmentDTO)
{
var environment = mapper.Map <Environment>(environmentDTO);
serviceEnvironment.Update(environment);
}
