public async Task <ActionResult <ActorDomainModel> > AddActor([FromBody] ActorModel actorModel)
{
ActorDomainModel domainModel = new ActorDomainModel
{
FirstName = actorModel.FirstName,
LastName = actorModel.LastName
};
ActorDomainModel createActor;
try
{
createActor = await _actorService.AddActor(domainModel);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (createActor == null)
{
return(BadRequest(Messages.ACTOR_CREATION_ERROR));
}
return(CreatedAtAction(nameof(GetActorById), new { Id = createActor.Id }, createActor));
}
public void GetAsync_Return_All_Actors()
{
//Arrange
ActorDomainModel actorDomainModel = new ActorDomainModel
{
Id = Guid.NewGuid(),
FirstName = "milan",
LastName = "petrovic"
};
int expectedStatusCode = 200;
int expectedResultCount = 1;
List <ActorDomainModel> actorDomainModels = new List <ActorDomainModel>();
actorDomainModels.Add(actorDomainModel);
IEnumerable <ActorDomainModel> actorsIEn = actorDomainModels;
Task <IEnumerable <ActorDomainModel> > responseTask = Task.FromResult(actorsIEn);
_actorService = new Mock <IActorService>();
_actorService.Setup(x => x.GetAllAsync()).Returns(responseTask);
ActorsController actorsController = new ActorsController(_actorService.Object);
//Act
var result = actorsController.GetAsync().ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultList = ((OkObjectResult)result).Value;
List <ActorDomainModel> actorDomainModelsResult = (List <ActorDomainModel>)resultList;
//Assert
Assert.IsNotNull(actorDomainModelsResult);
Assert.AreEqual(expectedResultCount, actorDomainModelsResult.Count);
Assert.AreEqual(actorDomainModel.Id, actorDomainModelsResult[0].Id);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
public void GetByIdAsync_Return_Actor_OkObjectResult()
{
//Arrange
ActorDomainModel actorDomainModel = new ActorDomainModel
{
Id = Guid.NewGuid(),
FirstName = "milan",
LastName = "petrovic"
};
int expectedStatusCode = 200;
Task <ActorDomainModel> responseTask = Task.FromResult(actorDomainModel);
_actorService = new Mock <IActorService>();
_actorService.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).Returns(responseTask);
ActorsController actorsController = new ActorsController(_actorService.Object);
//Act
var result = actorsController.GetById(actorDomainModel.Id).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultList = ((OkObjectResult)result).Value;
ActorDomainModel actorDomainModelsResult = (ActorDomainModel)resultList;
//Assert
Assert.IsNotNull(actorDomainModelsResult);
Assert.AreEqual(actorDomainModel.FirstName, actorDomainModelsResult.FirstName);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
public void CreateActorAsync_Create_IsSuccessful_True_Actor()
{
// Arrange
int expectedStatusCode = 201;
ActorModel actorModel = new ActorModel()
{
FirstName = "Ime",
LastName = "Prezime"
};
ActorDomainModel actorDomainModel = new ActorDomainModel
{
Id = 1,
FirstName = actorModel.FirstName,
LastName = actorModel.LastName
};
Task <ActorDomainModel> responseTask = Task.FromResult(actorDomainModel);
_actorService = new Mock <IActorService>();
_actorService.Setup(x => x.AddActor(It.IsAny <ActorDomainModel>())).Returns(responseTask);
ActorsController actorsController = new ActorsController(_actorService.Object);
// Act
var result = actorsController.AddActor(actorModel).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var createdResult = ((CreatedAtActionResult)result).Value;
var actorDomainModel1 = (ActorDomainModel)createdResult;
// Assert
Assert.IsNotNull(actorDomainModel1);
Assert.AreEqual(actorModel.FirstName, actorDomainModel1.FirstName);
Assert.IsInstanceOfType(result, typeof(CreatedAtActionResult));
Assert.AreEqual(expectedStatusCode, ((CreatedAtActionResult)result).StatusCode);
}
public async Task <ActorDomainModel> AddActor(ActorDomainModel actorModel)
{
// get all actors
var actors = await _actorsRepository.GetAllAsync();
// check if there is actor with same first name and last name
foreach (var actor in actors)
{
if (actor.FirstName == actorModel.FirstName && actor.LastName == actorModel.LastName)
{
return(null);
}
}
Actor actorToAdd = new Actor
{
FirstName = actorModel.FirstName,
LastName = actorModel.LastName
};
var addedActor = _actorsRepository.Insert(actorToAdd);
_actorsRepository.Save();
ActorDomainModel actorDomainModel = new ActorDomainModel
{
Id = addedActor.Id,
FirstName = addedActor.FirstName,
LastName = addedActor.LastName
};
return(actorDomainModel);
}
public async Task <ActionResult <ActorDomainModel> > GetById(Guid id)
{
ActorDomainModel actorDomainModel = await _actorService.GetByIdAsync(id);
if (actorDomainModel == null)
{
return(NotFound(Messages.ACTOR_NOT_FOUND));
}
return(Ok(actorDomainModel));
}
public async Task <ActorDomainModel> GetByIdAsync(Guid id)
{
var actor = await _actorsRepository.GetByIdAsync(id);
if (actor == null)
{
return(null);
}
ActorDomainModel actorModel = new ActorDomainModel
{
Id = actor.Id,
FirstName = actor.FirstName,
LastName = actor.LastName
};
return(actorModel);
}
public async Task <IEnumerable <ActorDomainModel> > GetAllAsync()
{
var actors = await _actorsRepository.GetAll();
List <ActorDomainModel> actorList = new List <ActorDomainModel>();
foreach (var actor in actors)
{
ActorDomainModel actorModel = new ActorDomainModel
{
Id = actor.Id,
FirstName = actor.FirstName,
LastName = actor.LastName
};
actorList.Add(actorModel);
}
return(actorList);
}
public void CreateActorAsync_Create_Throw_DbException_Actor()
{
// Arrange
string expectedMessage = "Inner exception error message.";
int expectedStatusCode = 400;
ActorModel actorModel = new ActorModel()
{
FirstName = "Ime",
LastName = "Prezime"
};
ActorDomainModel actorDomainModel = new ActorDomainModel
{
Id = 1,
FirstName = actorModel.FirstName,
LastName = actorModel.LastName
};
Task <ActorDomainModel> responseTask = Task.FromResult(actorDomainModel);
Exception exception = new Exception("Inner exception error message.");
DbUpdateException dbUpdateException = new DbUpdateException("Error.", exception);
_actorService = new Mock <IActorService>();
_actorService.Setup(x => x.AddActor(It.IsAny <ActorDomainModel>())).Throws(dbUpdateException);
ActorsController actorsController = new ActorsController(_actorService.Object);
// Act
var result = actorsController.AddActor(actorModel).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultResponse = (BadRequestObjectResult)result;
var badObjectResult = ((BadRequestObjectResult)result).Value;
var errorResult = (ErrorResponseModel)badObjectResult;
// Assert
Assert.IsNotNull(resultResponse);
Assert.AreEqual(expectedMessage, errorResult.ErrorMessage);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
Assert.AreEqual(expectedStatusCode, resultResponse.StatusCode);
}
public void GetByIdAsync_Return_Not_Found()
{
//Arrange
ActorDomainModel actorDomainModel = null;
int expectedStatusCode = 404;
string expectedMessage = Messages.ACTOR_NOT_FOUND;
Task <ActorDomainModel> responseTask = Task.FromResult(actorDomainModel);
_actorService = new Mock <IActorService>();
_actorService.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).Returns(responseTask);
ActorsController actorsController = new ActorsController(_actorService.Object);
//Act
var result = actorsController.GetById(Guid.NewGuid()).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultList = ((NotFoundObjectResult)result).Value;
string actorDomainModelsResult = (string)resultList;
//Assert
Assert.IsNotNull(actorDomainModelsResult);
Assert.IsInstanceOfType(result, typeof(NotFoundObjectResult));
Assert.AreEqual(expectedStatusCode, ((NotFoundObjectResult)result).StatusCode);
Assert.AreEqual(expectedMessage, actorDomainModelsResult);
}
