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 ForSession_ReturnsIdeasForSession(int testSessionId)
{
// Arrange
var fixture = new Fixture();
var newIdea = fixture.Create <NewIdeaModel>();
var validatorMock = new Mock <IValidatorStrategy <NewIdeaModel> >();
validatorMock.Setup(x => x.IsValid(newIdea)).Returns(true);
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync(GetTestSession());
var controller = new IdeasController(mockRepo.Object, validatorMock.Object);
// Act
var result = await controller.ForSession(testSessionId);
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <List <IdeaDTO> >(okResult.Value);
var idea = returnValue.FirstOrDefault();
Assert.Equal("One", idea.Name);
}
private void Awake()
{
projectController = ProjectController.Instance;
characterStatusController = CharacterStatusController.Instance;
ideasController = IdeasController.Instance;
gameManager = GameManager.Instance;
gameManager.OnGameStateChanged.AddListener(OnGameStateChangedHandler);
notificationController = GameObject.FindGameObjectWithTag("NotificationController").GetComponentInChildren <NotificationController>();
platformNameIdeas = new List <string>();
playerNameIdeas = new List <string>();
#region Select temp
goalSlot = new BaseWorkingProjectIdeaSlot();
mechanicSlots = new BaseWorkingProjectIdeaSlot[2];
for (int i = 0; i < mechanicSlots.Length; i++)
{
mechanicSlots[i] = new BaseWorkingProjectIdeaSlot();
}
themeSlots = new BaseWorkingProjectIdeaSlot();
countMechanicSlots = 0;
#endregion
Initializing();
}
public ActionResult Delete(FormCollection _form)
{
IdeasController nc = new IdeasController(Server);
return((ActionResult)nc.Delete(Request)["view"]);
//return null;
}
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 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 void CreateReturnsBadRequestGivenInvalidModel()
{
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object);
controller.ModelState.AddModelError("error", "some error");
var result = Assert.IsType <BadRequestObjectResult>(controller.Create(null));
}
public void ForSessionReturnsHttpNotFoundForInvalidSession()
{
var mockRepo = new Mock <IBrainstormSessionRepository>();
int testSessionId = 123;
mockRepo.Setup(r => r.GetById(testSessionId)).Returns((BrainstormSession)null);
var controller = new IdeasController(mockRepo.Object);
var result = Assert.IsType <HttpNotFoundObjectResult>(controller.ForSession(testSessionId));
}
public async Task Create_ResturnsBadRequest_GivenInvalidMidel()
{
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object);
controller.ModelState.AddModelError("error", "some error");
var result = await controller.Create(model : null);
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task Create_ReturnHttpNotFound_ForInvalidSession()
{
int testSessionId = 123;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(x => x.GetByIdAsync(testSessionId))
.ReturnsAsync((BrainstormSession)null);
var controller = new IdeasController(mockRepo.Object);
var result = await controller.Create(new NewIdeaModel());
Assert.IsType <NotFoundObjectResult>(result);
}
private void Awake()
{
_dialougeManager = DialougeManager.Instance;
_switchScene = SwitchScene.Instance;
_ideasController = IdeasController.Instance;
dialogues = new List <Dialogue>();
_notificationController = NotificationController.Instance;
_gameManager = GameManager.Instance;
if (!ReferenceEquals(_gameManager, null))
{
_gameManager.OnGameStateChanged.AddListener(OnGameStateChangedHandler);
}
}
public async Task Create_ReturnsBadRequest_GivenInvalidModel()
{
// Arrange & Act
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object);
controller.ModelState.AddModelError("error", "some error");
// Act
var result = await controller.Create(model : null);
// Assert
Assert.That(result, Is.TypeOf <BadRequestObjectResult>());
}
public void ReturnsIdeasForSession()
{
var mockRepo = new Mock <IBrainStormSessionRepository>();
int testSessionId = 123;
mockRepo.Setup(r => r.GetById(testSessionId)).Returns(GetTestSession());
var controller = new IdeasController(mockRepo.Object);
var result = Assert.IsType <ObjectResult>(controller.ForSession(testSessionId)).Value as IEnumerable <dynamic>;
dynamic idea = result.FirstOrDefault();
// this requires InternalsVisibleTo on the SUT project
Assert.Equal("One", idea.name);
}
public void ForSessionReturnsIdeasForSession()
{
var mockRepo = new Mock <IBrainstormSessionRepository>();
int testSessionId = 123;
mockRepo.Setup(r => r.GetById(testSessionId)).Returns(GetTestSession());
var controller = new IdeasController(mockRepo.Object);
var result = Assert.IsType <HttpOkObjectResult>(controller.ForSession(testSessionId));
var returnValue = Assert.IsType <List <IdeaDTO> >(result.Value);
var idea = returnValue.FirstOrDefault();
Assert.Equal("One", idea.name);
}
public async Task Create_ReturnsBadRequest_GivenInvalidModel()
{
// Arrange & Act
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object);
controller.ModelState.AddModelError("error", "some error");
// Act
var result = await controller.Create(model : null);
// Assert
//Assert.IsType<BadRequestObjectResult>(result);//xUnit Assert methode moet vervangen worden door gelijke Assert in NUnit:
Assert.IsInstanceOf <BadRequestObjectResult>(result);
}
public async Task ForSessionActionResult_ReturnsNotFoundObjectResultForNonexistentSession()
{
// Arrange
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object);
var nonExistentSessionId = 999;
// Act
var result = await controller.ForSessionActionResult(nonExistentSessionId);
// Assert
var actionResult = Assert.IsType <ActionResult <List <IdeaDTO> > >(result);
Assert.IsType <NotFoundObjectResult>(actionResult.Result);
}
public async Task ForSession_ResturnsHttpNotFound_ForInvalidSession()
{
int testSessionId = 123;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(x => x.GetByIdAsync(testSessionId))
.ReturnsAsync((BrainstormSession)null);
var controller = new IdeasController(mockRepo.Object);
var result = await controller.ForSession(testSessionId);
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.Equal(testSessionId, notFoundObjectResult.Value);
}
public async Task CreateActionResult_ReturnsBadRequest_GivenInvalidModel()
{
// Arrange & Act
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object);
controller.ModelState.AddModelError("error", "some error");
// Act
var result = await controller.CreateActionResult(model : null);
// Assert
var actionResult = Assert.IsType <ActionResult <BrainstormSession> >(result);
Assert.IsType <BadRequestObjectResult>(actionResult.Result);
}
public async Task IdeasController_CreateActionResult_LogErrorMessage_WhenModelStateIsInvalid()
{
// Arrange & Act
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object);
controller.ModelState.AddModelError("error", "some error");
// Act
await controller.CreateActionResult(model : new NewIdeaModel());
// Assert
var logEntries = this.appender.GetEvents();
Assert.True(logEntries.Any(l => l.Level == Level.Error), "Expected Error messages in the logs");
}
public async Task Create_ReturnsHttpNotFound_ForInvalidSession()
{
// Arrange
int testSessionId = 123;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync((BrainstormSession)null);
var controller = new IdeasController(mockRepo.Object);
// Act
var result = await controller.Create(new NewIdeaModel());
// Assert
Assert.That(result, Is.TypeOf <NotFoundObjectResult>());
}
public async Task ForSession_ResturnsIdeasForSession()
{
int testSessionId = 1;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(x => x.GetByIdAsync(testSessionId))
.ReturnsAsync((BrainstormSession)null);
var controller = new IdeasController(mockRepo.Object);
var result = await controller.ForSession(testSessionId);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <List <IdeaDTO> >(okResult.Value);
var idea = returnValue.FirstOrDefault();
Assert.Equal("One", idea.Name);
}
public async Task Create_ReturnsBadRequest_GivenInvalidModel()
{
// Arrange & Act
var fixture = new Fixture();
var newIdea = fixture.Create <NewIdeaModel>();
var validatorMock = new Mock <IValidatorStrategy <NewIdeaModel> >();
validatorMock.Setup(x => x.IsValid(newIdea)).Returns(false);
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new IdeasController(mockRepo.Object, validatorMock.Object);
// controller.ModelState.AddModelError("error", "some error");
var model = fixture.Build <NewIdeaModel>().Without(x => x.Name).Without(x => x.Description).Create();
// Act
var result = await controller.Create(model);
// Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task ForSession_ReturnsHttpNotFound_ForInvalidSession()
{
// Arrange
int testSessionId = 123;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync((BrainstormSession)null);
var controller = new IdeasController(mockRepo.Object);
// Act
var result = await controller.ForSession(testSessionId);
// Assert
Assert.That(result, Is.TypeOf <NotFoundObjectResult>());
var notFoundObjectResult = result as NotFoundObjectResult;
Assert.AreEqual(testSessionId, notFoundObjectResult.Value);
}
public async Task ForSession_ReturnsIdeasForSession()
{
// Arrange
int testSessionId = 123;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId)).Returns(Task.FromResult(GetTestSession()));
var controller = new IdeasController(mockRepo.Object);
// Act
var result = await controller.ForSession(testSessionId);
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <List <IdeaDTO> >(okResult.Value);
var idea = returnValue.FirstOrDefault();
Assert.Equal("One", idea.Name);
}
public IdeasControllerTests()
{
var ideaData = new List <Idea>
{
new Idea {
id = "abcdef", content = "Idea 1", confidence = 5, ease = 6, impact = 7, created_at = System.DateTime.UtcNow
},
new Idea {
id = "ghijkl", content = "Idea 2", confidence = 8, ease = 9, impact = 10, created_at = System.DateTime.UtcNow
},
}.AsQueryable();
var ideaMockSet = new Mock <DbSet <Idea> >();
ideaMockSet.As <IAsyncEnumerable <Idea> >().Setup(m => m.GetEnumerator()).Returns(new TestAsyncEnumerator <Idea>(ideaData.GetEnumerator()));
ideaMockSet.As <IQueryable <Idea> >().Setup(m => m.Provider).Returns(new TestAsyncQueryProvider <Idea>(ideaData.Provider));
ideaMockSet.As <IQueryable <Idea> >().Setup(m => m.Expression).Returns(ideaData.Expression);
ideaMockSet.As <IQueryable <Idea> >().Setup(m => m.ElementType).Returns(ideaData.ElementType);
ideaMockSet.As <IQueryable <Idea> >().Setup(m => m.GetEnumerator()).Returns(ideaData.GetEnumerator());
_ideaRepositoryMock.Setup(m => m.Query()).Returns(ideaMockSet.Object.AsQueryable());
var mockCtx = new Mock <IdeasDbContext>();
mockCtx.SetupGet(c => c.Ideas).Returns(ideaMockSet.Object);
var userData = new List <User>
{
new User {
email = "*****@*****.**", name = "John Doe", password = "******"
},
}.AsQueryable();
var userMockSet = new Mock <DbSet <User> >();
userMockSet.As <IAsyncEnumerable <User> >().Setup(m => m.GetEnumerator()).Returns(new TestAsyncEnumerator <User>(userData.GetEnumerator()));
userMockSet.As <IQueryable <User> >().Setup(m => m.Provider).Returns(new TestAsyncQueryProvider <User>(userData.Provider));
userMockSet.As <IQueryable <User> >().Setup(m => m.Expression).Returns(userData.Expression);
userMockSet.As <IQueryable <User> >().Setup(m => m.ElementType).Returns(userData.ElementType);
userMockSet.As <IQueryable <User> >().Setup(m => m.GetEnumerator()).Returns(userData.GetEnumerator());
_userRepositoryMock.Setup(m => m.Query()).Returns(userMockSet.Object.AsQueryable());
mockCtx.SetupGet(c => c.Users).Returns(userMockSet.Object);
_ideasController = new IdeasController(_ideaRepositoryMock.Object, _userRepositoryMock.Object);
}
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 IdeaControllerTests()
{
model = new IdeaViewModel()
{
content = "some content",
ease = 4,
impact = 3,
confidence = 4
};
mapper = A.Fake <IMapper>();
validator = A.Fake <IValidator <IdeaViewModel> >();
context = A.Fake <IIdeaPoolContext>();
sut = new IdeasController(validator, mapper, context);
var claimsPrincipal = A.Fake <ClaimsPrincipal>();
A.CallTo(() => claimsPrincipal.Claims).Returns(
new List <Claim>()
{
new Claim(ClaimTypes.NameIdentifier, Guid.NewGuid().ToString())
});
sut.ControllerContext.HttpContext = new DefaultHttpContext();
sut.ControllerContext.HttpContext.User = claimsPrincipal;
}
public async Task ForSession_ReturnsHttpNotFound_ForInvalidSession()
{
// Arrange
var testSessionId = 123;
var fixture = new Fixture();
var newIdea = fixture.Create <NewIdeaModel>();
var validatorMock = new Mock <IValidatorStrategy <NewIdeaModel> >();
validatorMock.Setup(x => x.IsValid(newIdea)).Returns(true);
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync((BrainstormSession)null);
var controller = new IdeasController(mockRepo.Object, validatorMock.Object);
// Act
var result = await controller.ForSession(testSessionId);
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.Equal(testSessionId, notFoundObjectResult.Value);
}
public async Task ForSessionActionResult_ReturnsIdeasForSession()
{
// Arrange
int testSessionId = 123;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync(GetTestSession());
var controller = new IdeasController(mockRepo.Object);
// Act
var result = await controller.ForSessionActionResult(testSessionId);
// Assert
Assert.That(result, Is.TypeOf <ActionResult <List <IdeaDTO> > >());
var actionResult = result as ActionResult <List <IdeaDTO> >;
Assert.That(actionResult.Value, Is.TypeOf <List <IdeaDTO> >());
var returnValue = actionResult.Value as List <IdeaDTO>;
var idea = returnValue.FirstOrDefault();
Assert.AreEqual("One", idea.Name);
}
