public async Task <ActionResult <BrainstormSession> > CreateActionResult([FromBody] NewIdeaModel model)
{
if (!ModelState.IsValid)
{
Logger.Error($"Passed model is not valid: {model}");
return(BadRequest(ModelState));
}
var session = await _sessionRepository.GetByIdAsync(model.SessionId);
if (session == null)
{
return(NotFound(model.SessionId));
}
var idea = new Idea()
{
DateCreated = DateTimeOffset.Now,
Description = model.Description,
Name = model.Name
};
session.AddIdea(idea);
await _sessionRepository.UpdateAsync(session);
return(CreatedAtAction(nameof(CreateActionResult), new { id = session.Id }, session));
}
public async Task <IActionResult> Create([FromBody] NewIdeaModel model)
{
if (!ModelState.IsValid)
{
Logger.Error($"Passed model is not valid: {model}");
return(BadRequest(ModelState));
}
var session = await _sessionRepository.GetByIdAsync(model.SessionId);
if (session == null)
{
Logger.Warn($"Session with id: {model.SessionId} is not found");
return(NotFound(model.SessionId));
}
var idea = new Idea()
{
DateCreated = DateTimeOffset.Now,
Description = model.Description,
Name = model.Name
};
session.AddIdea(idea);
await _sessionRepository.UpdateAsync(session);
return(Ok(session));
}
public async Task CreateActionResult_ReturnsNotFoundObjectResultForNonexistentSession()
{
// Arrange
var nonExistentSessionId = 999;
string testName = "test name";
string testDescription = "test description";
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object);
var newIdea = new NewIdeaModel()
{
Description = testDescription,
Name = testName,
SessionId = nonExistentSessionId
};
// Act
var result = await controller.CreateActionResult(newIdea);
// Assert
Assert.That(result, Is.TypeOf <ActionResult <BrainstormSession> >());
var actionResult = result as ActionResult <BrainstormSession>;
Assert.That(actionResult.Result, Is.TypeOf <NotFoundObjectResult>());
}
public async Task <ActionResult <BrainstormSession> > CreateActionResult([FromBody] NewIdeaModel model)
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
if (!this.ModelState.IsValid)
{
Logger.Log.Error($"Modelstate in method {nameof(this.CreateActionResult)} has {this.ModelState.ErrorCount} errors");
return(this.BadRequest(this.ModelState));
}
var session = await this.sessionRepository.GetByIdAsync(model.SessionId);
if (session == null)
{
return(this.NotFound(model.SessionId));
}
var idea = new Idea()
{
DateCreated = DateTimeOffset.Now,
Description = model.Description,
Name = model.Name,
};
session.AddIdea(idea);
await this.sessionRepository.UpdateAsync(session);
return(this.CreatedAtAction(nameof(this.CreateActionResult), new { id = session.Id }, session));
}
public async Task <IActionResult> Create([FromBody] NewIdeaModel model)
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var session = await this.sessionRepository.GetByIdAsync(model.SessionId);
if (session == null)
{
return(this.NotFound(model.SessionId));
}
var idea = new Idea()
{
DateCreated = DateTimeOffset.Now,
Description = model.Description,
Name = model.Name,
};
session.AddIdea(idea);
await this.sessionRepository.UpdateAsync(session);
return(this.Ok(session));
}
public async Task <IActionResult> Create([FromBody] NewIdeaModel model)
{
if (_validator.IsValid(model) == false)
{
return(BadRequest(ModelState));
}
var session = await _sessionRepository.GetByIdAsync(model.SessionId);
if (session == null)
{
return(NotFound(model.SessionId));
}
var idea = new Idea()
{
DateCreated = DateTimeOffset.Now,
Description = model.Description,
Name = model.Name
};
session.AddIdea(idea);
await _sessionRepository.UpdateAsync(session);
return(Ok(session));
}
public void CreateReturnsNewlyCreatedIdeaForSession()
{
var mockRepo = new Mock <IBrainstormSessionRepository>();
int testSessionId = 123;
string testName = "test name";
string testDescription = "test description";
var testSession = GetTestSession();
mockRepo.Setup(r => r.GetById(testSessionId)).Returns(testSession);
var controller = new IdeasController(mockRepo.Object);
var newIdea = new NewIdeaModel()
{
Description = testDescription,
Name = testName,
SessionId = testSessionId
};
mockRepo.Setup(r => r.Update(testSession)).Verifiable();
var result = Assert.IsType <HttpOkObjectResult>(controller.Create(newIdea));
var returnSession = Assert.IsType <BrainstormSession>(result.Value);
mockRepo.Verify();
Assert.Equal(2, returnSession.Ideas.Count());
Assert.Equal(testName, returnSession.Ideas.LastOrDefault().Name);
Assert.Equal(testDescription, returnSession.Ideas.LastOrDefault().Description);
}
public async Task <IActionResult> Create([FromBody] NewIdeaModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var session = await _sessionRepository.GetByIdAsync(model.SessionId);
if (session == null)
{
if (Logger.useLogs)
{
Logger.Log.Error("Session not found");
}
return(NotFound(model.SessionId));
}
var idea = new Idea()
{
DateCreated = DateTimeOffset.Now,
Description = model.Description,
Name = model.Name
};
session.AddIdea(idea);
Logger.Log.Debug($"idea.DateCreated: {idea.DateCreated} idea.Name: {idea.Name} idea.Id: {idea.Id}");
await _sessionRepository.UpdateAsync(session);
return(Ok(session));
}
public async Task Create_ReturnNewCreatedIdeaForSession()
{
int testSessionId = 123;
string testName = "test name";
string testDescription = "test description";
var testSession = GetTestSession();
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync(testSession);
var controller = new IdeasController(mockRepo.Object);
var newIdea = new NewIdeaModel()
{
Description = testDescription,
Name = testName,
SessionId = testSessionId
};
mockRepo.Setup(x => x.UpdateAsync(testSession))
.Returns(Task.CompletedTask)
.Verifiable();
var result = await controller.CreateActionResult(newIdea);
var actionResult = Assert.IsType <ActionResult <BrainstormSession> >(result);
var createAtActionResult = Assert.IsType <CreatedAtActionResult>(actionResult.Result);
var returnValue = Assert.IsType <BrainstormSession>(createAtActionResult.Value);
mockRepo.Verify();
Assert.Equal(2, returnValue.Ideas.Count);
Assert.Equal(testName, returnValue.Ideas.LastOrDefault().Name);
Assert.Equal(testDescription, returnValue.Ideas.LastOrDefault().Description);
}
public async Task <IActionResult> Remove(int ideaId, [FromBody] NewIdeaModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var session = await _sessionRepository.GetByIdAsync(model.SessionId);
if (session == null)
{
return(NotFound(model.SessionId));
}
var idea = session.Ideas.Find(i => i.Id.Equals(ideaId));
if (idea == null)
{
return(NotFound(ideaId));
}
session.Ideas.Remove(idea);
await _sessionRepository.UpdateAsync(session);
return(Ok(session));
}
public async Task CreateActionResult_ReturnsNewlyCreatedIdeaForSession()
{
// Arrange
int testSessionId = 123;
string testName = "test name";
string testDescription = "test description";
var testSession = GetTestSession();
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync(testSession);
var controller = new IdeasController(mockRepo.Object);
var newIdea = new NewIdeaModel()
{
Description = testDescription,
Name = testName,
SessionId = testSessionId
};
mockRepo.Setup(repo => repo.UpdateAsync(testSession))
.Returns(Task.CompletedTask)
.Verifiable();
// Act
var result = await controller.CreateActionResult(newIdea);
// Assert
Assert.That(result, Is.TypeOf <ActionResult <BrainstormSession> >());
var actionResult = result as ActionResult <BrainstormSession>;
Assert.That(actionResult.Result, Is.TypeOf <CreatedAtActionResult>());
var createdAtActionResult = actionResult.Result as CreatedAtActionResult;
Assert.That(createdAtActionResult.Value, Is.TypeOf <BrainstormSession>());
var returnValue = createdAtActionResult.Value as BrainstormSession;
mockRepo.Verify();
Assert.AreEqual(2, returnValue.Ideas.Count());
Assert.AreEqual(testName, returnValue.Ideas.LastOrDefault().Name);
Assert.AreEqual(testDescription, returnValue.Ideas.LastOrDefault().Description);
}
public async Task Create_ReturnsNewlyCreatedIdeaForSession()
{
// Arrange
int testSessionId = 123;
string testName = "test name";
string testDescription = "test description";
var testSession = GetTestSession();
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync(testSession);
var controller = new IdeasController(mockRepo.Object);
var newIdea = new NewIdeaModel()
{
Description = testDescription,
Name = testName,
SessionId = testSessionId
};
mockRepo.Setup(repo => repo.UpdateAsync(testSession))
.Returns(Task.CompletedTask)
.Verifiable();
// Act
var result = await controller.Create(newIdea);
// Assert
//var okResult = Assert.IsType<OkObjectResult>(result); xUnit
Assert.That(result, Is.TypeOf <OkObjectResult>()); //of Assert.IsInstanceOf<OkObjectResult>(result); Nunit
var okResult = result as OkObjectResult;
//var returnSession = Assert.IsType<BrainstormSession>(okResult.Value); xUnit
Assert.That(okResult.Value, Is.TypeOf <BrainstormSession>());//of Assert.IsInstanceOf<....
var returnSession = okResult.Value as BrainstormSession;
mockRepo.Verify();
Assert.AreEqual(2, returnSession.Ideas.Count());
Assert.AreEqual(testName, returnSession.Ideas.LastOrDefault().Name);
Assert.AreEqual(testDescription, returnSession.Ideas.LastOrDefault().Description);
}
public IActionResult Create([FromBody] NewIdeaModel model)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
var session = _sessionRepository.GetById(model.SessionId);
if (session == null)
{
return(HttpNotFound(model.SessionId));
}
var idea = new Idea()
{
DateCreated = DateTime.Now,
Description = model.Description,
Name = model.Name
};
session.AddIdea(idea);
_sessionRepository.Update(session);
return(new ObjectResult(session));
}
