public async Task CreateGroup_ReturnsBadRequest()
{
_controller.ModelState.AddModelError("", "");
var result = await _controller.CreateGroup(new Group());
var contentResult = result as InvalidModelStateResult;
Assert.IsNotNull(contentResult);
Assert.AreEqual(contentResult.ModelState.Keys.Count, 1);
}
public void CreateWorkSpace()
{
//Setup a fake HttpRequest
Mock <HttpContextBase> moqContext = new Mock <HttpContextBase>();
Mock <HttpRequestBase> moqRequest = new Mock <HttpRequestBase>();
Mock <HttpPostedFileBase> moqPostedFile = new Mock <HttpPostedFileBase>();
moqRequest.Setup(r => r.Files.Count).Returns(0);
moqContext.Setup(x => x.Request).Returns(moqRequest.Object);
//arrange
var controller = new GroupController();
var workspace = new WorkSpace()
{
WorkSpaceName = "WorkSpace TestCorrect",
Bilimail = "*****@*****.**",
Description = "Demo test is correct",
ImageWS = "name.jpg"
};
controller.ControllerContext = new ControllerContext(moqContext.Object, new RouteData(), controller);
var validationResults = TestModelHelper.ValidateModel(controller, workspace);
//act
var redirectRoute = controller.CreateGroup(workspace) as RedirectToRouteResult;
//assert
Assert.IsNotNull(redirectRoute);
Assert.AreEqual("Index", redirectRoute.RouteValues["action"]);
//Assert.AreEqual("Home", redirectRoute.RouteValues["controller"]);
Assert.AreEqual(0, validationResults.Count);
}
public async Task CreateGroupIfNull_ReturnsCorrectResponse()
{
var options = new DbContextOptionsBuilder <RepositoryContext>().UseInMemoryDatabase(databaseName: "CreateGroupIfNull_ReturnsCorrectResponse").Options;
var _context = new RepositoryContext(options);
logger = new LoggerManager();
repository = new RepositoryWrapper(_context);
var controller = new GroupController(logger, repository);
seed(_context);
var result = controller.CreateGroup(new Group {
});
var result1 = controller.CreateGroup(null);
Assert.IsAssignableFrom <IActionResult>(result);
Assert.IsAssignableFrom <IActionResult>(result1);
}
public void CreateGroup_CreateGroupViewEqualsCreateGroupCshtml_Returns_CorrectView()
{
//Arrange
GroupController groupController = new GroupController();
//Act
var result = groupController.CreateGroup() as ViewResult;
//Assert
Assert.AreEqual("CreateGroup", result.ViewName);
}
public async Task CreateGroup_ShouldReturnBadRequestResult_WhenModelValidationFails()
{
// Arrange
GroupController controller = new GroupController(null, null);
controller.ModelState.AddModelError("", "");
// Act
ActionResult <GroupResource> response = await controller.CreateGroup(null);
// Assert
Assert.IsType <BadRequestObjectResult>(response.Result);
}
public static SimpleCreateGroupResponse CreateGroup(string groupName)
{
SimpleCreateGroupResponse response = new SimpleCreateGroupResponse();
if (string.IsNullOrWhiteSpace(groupName))
{
response.Success = false;
response.ErrorMessage = "Invalid Group Name";
return(response);
}
response.Group = ExecuteControllerAction(() => GroupController.CreateGroup(groupName, 1), response);
return(response);
}
public void CreateGroup_Invalid_TenantId_or_GroupName(string groupName, int tenantId)
{
//Given
Group group = new Group()
{
GroupName = groupName,
Description = "Group"
};
//When
var controller = new GroupController(logger.Object, groupServiceMoq.Object);
var response = controller.CreateGroup(group, tenantId) as BadRequestObjectResult;
//Then
Assert.IsType <BadRequestObjectResult>(response);
Assert.Equal($"Invalid tenantId : {tenantId} or GroupName : {group.GroupName}", response.Value);
}
public async Task CreateGroup_ShouldReturnCreatedResult_WhenGroupIsCreated()
{
// Arrange
CreateGroupBody model = new CreateGroupBody
{
Name = "Some group name",
Description = "Some group description"
};
GroupResource expectedGroup = new GroupResource
{
GroupId = 1,
Name = model.Name,
Description = model.Description
};
Mock <IMediator> mediatorMock = new Mock <IMediator>();
mediatorMock
.Setup(m => m.Send(It.IsAny <CreateGroupCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedGroup);
MapperConfiguration mapperConfiguration = new MapperConfiguration(config =>
{
config.CreateMap <CreateGroupBody, CreateGroupCommand>();
});
IMapper mapperMock = mapperConfiguration.CreateMapper();
GroupController controller = new GroupController(mediatorMock.Object, mapperMock);
// Act
ActionResult <GroupResource> response = await controller.CreateGroup(model);
// Assert
CreatedAtActionResult result = Assert.IsType <CreatedAtActionResult>(response.Result);
GroupResource actualGroup = Assert.IsType <GroupResource>(result.Value);
Assert.NotNull(actualGroup);
Assert.Equal(1, actualGroup.GroupId);
mediatorMock.Verify(m => m.Send(It.IsAny <CreateGroupCommand>(), It.IsAny <CancellationToken>()));
}
public async Task CreateGroupIfModelInvalid_ReturnsCorrectResponse()
{
var options = new DbContextOptionsBuilder <RepositoryContext>().UseInMemoryDatabase(databaseName: "CreateGroupIfModelInvalid_ReturnsCorrectResponse").Options;
var _context = new RepositoryContext(options);
logger = new LoggerManager();
repository = new RepositoryWrapper(_context);
var controller = new GroupController(logger, repository);
seed(_context);
var grp = new Group();
var context = new ValidationContext(grp, null, null);
var results = new List <ValidationResult>();
var isModelStateValid = Validator.TryValidateObject(grp, context, results, true);
controller.ModelState.AddModelError("test", "test");
var result = controller.CreateGroup(grp);
Assert.IsAssignableFrom <IActionResult>(result);
}
public void CreateGroup_UnSuccessfull()
{
//Given
int tenantId = 1, groupCreated = 0;
Group group = new Group()
{
GroupName = "Group 1",
Description = "Group"
};
groupServiceMoq.Setup(g => g.CreateGroup(tenantId, group)).Returns(groupCreated);
//When
var controller = new GroupController(logger.Object, groupServiceMoq.Object);
var response = controller.CreateGroup(group, tenantId) as NotFoundObjectResult;
//Then
Assert.IsType <NotFoundObjectResult>(response);
Assert.Equal("Group Creation unsuccessfull", response.Value);
groupServiceMoq.Verify(g => g.CreateGroup(tenantId, group), Times.Once);
}
public void CreateGroupWorking()
{
Assert.AreEqual(true, gc.CreateGroup("Group Name", profileId));
}
private void LoadApiDictionary()
{
apiDictionary = new Dictionary <string, FunctionCaller>();
FunctionCaller loginGuest = new FunctionCaller()
{
};
loginGuest.functionNoParams = authentication.Login;
apiDictionary.Add("Login as guest", loginGuest);
FunctionCaller loginUser = new FunctionCaller();
loginUser.function2Params = (username, password) => authentication.Login(username, password);
loginUser.parameters.Add("Username");
loginUser.parameters.Add("Password");
apiDictionary.Add("Login user with id", loginUser);
FunctionCaller createAccount = new FunctionCaller();
createAccount.function3Params = (email, username, password) => authentication.CreateAccount(email, username, password);
createAccount.parameters.Add("Email");
createAccount.parameters.Add("Username");
createAccount.parameters.Add("Password");
apiDictionary.Add("Create account with email", createAccount);
FunctionCaller changeBackgroundColor = new FunctionCaller();
changeBackgroundColor.functionNoParams = () => backgroundColorChanger.ChangeBackgroundColor();
apiDictionary.Add("Change background color", changeBackgroundColor);
FunctionCaller saveBackgroundColor = new FunctionCaller();
saveBackgroundColor.functionNoParams = () => backgroundColorChanger.SaveBackgroundColor();
apiDictionary.Add("Save background color", saveBackgroundColor);
FunctionCaller getBackgroundColor = new FunctionCaller();
getBackgroundColor.functionNoParams = () => backgroundColorChanger.GetBackgroundColor();
apiDictionary.Add("Get background color", getBackgroundColor);
FunctionCaller createGroup = new FunctionCaller();
createGroup.function3Params = (adminUsername, password, groupName) => groupController.CreateGroup(adminUsername, password, groupName);
createGroup.parameters.Add("Admin Username");
createGroup.parameters.Add("Password");
createGroup.parameters.Add("Group Name");
apiDictionary.Add("Create group", createGroup);
FunctionCaller invitePlayerToGroup = new FunctionCaller();
invitePlayerToGroup.function4Params =
(adminUsername, password, groupName, usernameToInvite) =>
groupController.InvitePlayerToGroup(adminUsername, password, groupName, usernameToInvite);
invitePlayerToGroup.parameters.Add("Admin Username");
invitePlayerToGroup.parameters.Add("Password");
invitePlayerToGroup.parameters.Add("Group Name");
invitePlayerToGroup.parameters.Add("Username To Invite");
apiDictionary.Add("Invite player to group", invitePlayerToGroup);
FunctionCaller acceptInvitationToGroup = new FunctionCaller();
acceptInvitationToGroup.function3Params =
(usernameToAccept, password, groupName) =>
groupController.AcceptInvitationToGroup(usernameToAccept, password, groupName);
acceptInvitationToGroup.parameters.Add("Username To Accept");
acceptInvitationToGroup.parameters.Add("Password");
acceptInvitationToGroup.parameters.Add("Group Name");
apiDictionary.Add("Accept invitation to group", acceptInvitationToGroup);
FunctionCaller fetchApiPolicy = new FunctionCaller();
fetchApiPolicy.functionNoParams = () => apiAccessPolicyController.FetchApiPolicy();
apiDictionary.Add("Fetch API access policy", fetchApiPolicy);
FunctionCaller readDropTableData = new FunctionCaller();
readDropTableData.function1Param = (tableId) => dropTableController.ReadDropTableData(tableId);
readDropTableData.parameters.Add("Drop table id");
apiDictionary.Add("Read drop table data", readDropTableData);
FunctionCaller grantRandomItemToUser = new FunctionCaller();
grantRandomItemToUser.function4Params =
(adminUsername, password, usernameReceivingItem, dropTableId) =>
dropTableController.GrantRandomItemToUser(adminUsername, password, usernameReceivingItem, dropTableId);
grantRandomItemToUser.parameters.Add("Admin Username");
grantRandomItemToUser.parameters.Add("Password");
grantRandomItemToUser.parameters.Add("Username Receiving Item");
grantRandomItemToUser.parameters.Add("Drop Table Id");
apiDictionary.Add("Grant user random item", grantRandomItemToUser);
FunctionCaller purchaseItem = new FunctionCaller();
purchaseItem.function4Params =
(username, password, itemId, price) =>
playerInventoryController.PurchaseItem(username, password, itemId, price);
purchaseItem.parameters.Add("Username");
purchaseItem.parameters.Add("Password");
purchaseItem.parameters.Add("Item Id");
purchaseItem.parameters.Add("Price");
apiDictionary.Add("Purchase item", purchaseItem);
FunctionCaller getInventory = new FunctionCaller();
getInventory.function2Params = (username, password) => playerInventoryController.GetInventory(username, password);
getInventory.parameters.Add("Username");
getInventory.parameters.Add("Password");
apiDictionary.Add("Get inventory", getInventory);
FunctionCaller consumeItem = new FunctionCaller();
consumeItem.function3Params = (username, password, itemId) => playerInventoryController.ConsumeItem(username, password, itemId);
consumeItem.parameters.Add("Username");
consumeItem.parameters.Add("Password");
consumeItem.parameters.Add("Item Id");
apiDictionary.Add("Consume item", consumeItem);
FunctionCaller redeemCoupon = new FunctionCaller();
redeemCoupon.function3Params = (username, password, couponCode) => couponController.RedeemCoupon(username, password, couponCode);
redeemCoupon.parameters.Add("Username");
redeemCoupon.parameters.Add("Password");
redeemCoupon.parameters.Add("Coupon Code");
apiDictionary.Add("Redeem Coupon", redeemCoupon);
FunctionCaller updatePlayerStatistic = new FunctionCaller();
updatePlayerStatistic.function2Params = (username, password) => statisticsController.UpdatePlayerStatistics(username, password);
updatePlayerStatistic.parameters.Add("Username");
updatePlayerStatistic.parameters.Add("Password");
apiDictionary.Add("Update player statistic", updatePlayerStatistic);
}
