public void GetUserListTest()
{
AdministrationController target = new AdministrationController(); // TODO: Initialize to an appropriate value
ActionResult actual = null;
actual = target.GetUserList();
Assert.IsTrue(actual != null);
}
public void GenFormLoginTest()
{
AdministrationController target = new AdministrationController(); // TODO: Initialize to an appropriate value
string user = string.Empty; // TODO: Initialize to an appropriate value
string password = string.Empty; // TODO: Initialize to an appropriate value
ActionResult expected = null; // TODO: Initialize to an appropriate value
ActionResult actual;
actual = target.GenFormLogin(user, password);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void GetAllGroupsAndMessages_Should_RenderViewWithNullParameters_WhenThereAreNoSuch()
{
var userServiceMocked = new Mock <IUserService>();
var groupsServiceMocked = new Mock <IGroupService>();
var friendListServiceMocked = new Mock <IFriendListService>();
groupsServiceMocked.Setup(m => m.GetAll())
.Returns(new List <Group>());
var controller = new AdministrationController(groupsServiceMocked.Object,
friendListServiceMocked.Object, userServiceMocked.Object);
controller
.WithCallTo(m => m.GetAllGroupsAndMessages())
.ShouldRenderDefaultView()
.WithModel <List <GroupViewModel> >(viewModel =>
{
Assert.AreEqual(viewModel.Count, 0);
});
}
public AdministrationControllerTest()
{
var mapper = new Mock <IMapper>();
_userService = new Mock <IUserService>();
var httpContext = new Mock <HttpContext>();
httpContext.Setup(g => g.User.Identity.Name).Returns("user");
var actionContext = new ActionContext();
actionContext.HttpContext = httpContext.Object;
actionContext.ActionDescriptor = new ControllerActionDescriptor();
actionContext.RouteData = new RouteData();
var controllerContext = new ControllerContext(actionContext);
_administrationController = new AdministrationController(_userService.Object, mapper.Object)
{
ControllerContext = controllerContext
};
}
public void SetOrderState_ReturnsBadRequest_Problem()
{
// Arrange
var order = new Order
{
Id = 1,
PhoneNumber = "098765432",
City = "Bucharest",
OrderTotal = 100
};
var mockRepositoryWrapper = new Mock <IRepositoryWrapper>();
mockRepositoryWrapper.Setup(repo => repo.Order.GetOrderByIdAsNoTraking(order.Id));
var mockAdministrationService = new Mock <IAdministrationService>();
var controller = new AdministrationController(mockRepositoryWrapper.Object, mockAdministrationService.Object);
//Act
var result = controller.SetOrderState(order);
//Assert
var badRequestResult = Assert.IsType <NotFoundResult>(result.Result);
}
public async Task AdministrationControllerTest_UpdateRegionAsync()
{
// Arrange
var controller = new AdministrationController(service);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
var model = new Region()
{
RegionDescription = "Acme Region 2",
};
var result = await controller.UpdateRegion(5, model);
// Assert
var value = default(ISingleModelResponse <Region>);
result.TryGetContentValue(out value);
Assert.IsTrue(value.Message == "Record updated successfully");
}
public void SetupController()
{
var mockLogger = new Mock <ILogger <AdministrationController> >();
var mockRoleManager = new Mock <RoleManager <IdentityRole> >(
new Mock <IRoleStore <IdentityRole> >().Object,
new IRoleValidator <IdentityRole> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <ILogger <RoleManager <IdentityRole> > >().Object);
var identityRoles = new List <IdentityRole>()
{
new IdentityRole("HRSUser"), new IdentityRole("SuperAdmin"), new IdentityRole("TenantAdmin")
};
mockRoleManager.Setup(r => r.Roles).Returns(Queryable.AsQueryable(identityRoles));
IdentityError[] errors = new IdentityError[] { new IdentityError() };
mockRoleManager.SetupSequence(r => r.CreateAsync(It.IsAny <IdentityRole>())).ReturnsAsync(IdentityResult.Success).ReturnsAsync(IdentityResult.Failed(errors));
mockRoleManager.Setup(r => r.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(identityRoles[0]);
mockRoleManager.SetupSequence(r => r.UpdateAsync(It.IsAny <IdentityRole>())).ReturnsAsync(IdentityResult.Success).ReturnsAsync(IdentityResult.Failed(errors));
mockRoleManager.SetupSequence(r => r.DeleteAsync(It.IsAny <IdentityRole>())).ReturnsAsync(IdentityResult.Success).ReturnsAsync(IdentityResult.Failed(errors));
administrationController = new AdministrationController(mockRoleManager.Object, Mapper, mockLogger.Object);
}
public void AddCake_ReturnsAddCakeViewModel_Success()
{
// Arrange
var categoryList = new List <Category> {
new Category {
Id = 1, Name = "VanillaCakes"
}
};
var mockRepositoryWrapper = new Mock <IRepositoryWrapper>();
mockRepositoryWrapper.Setup(repo => repo.Category.GetAllAsync()).Returns(Task.FromResult(categoryList));
var mockAdministrationService = new Mock <IAdministrationService>();
var controller = new AdministrationController(mockRepositoryWrapper.Object, mockAdministrationService.Object);
// Act
var result = controller.AddCake();
// Assert
var addCakeViewModelResult = Assert.IsType <Task <AddCakeViewModel> >(result);
Assert.NotNull(addCakeViewModelResult);
Assert.NotNull(result.Result);
}
public void DbInfoAddFromFile_ShouldReturnOkResult()
{
string testFile = "";
var dbFillerMock = new Mock <IGlassesInfoDbFiller>();
dbFillerMock.Setup(x => x.FillInfo(null, testFile));
HttpContext.Current = new HttpContext(new HttpRequest(testFile, "http://testUri.com", null), new HttpResponse(null));
var flagService = new Mock <IFlagService>();
flagService.Setup(x => x.GetFlagValue(FlagType.ShowOnlyHighCostGroups)).Returns(() => true);
var controller = new AdministrationController(dbFillerMock.Object, null, flagService.Object);
var result = controller.DbInfoAddFromFile();
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <string>));
var responseContent = ((OkNegotiatedContentResult <string>)result).Content;
Assert.AreEqual(responseContent, GlobalConstants.DbFilledInFinishedMessage);
dbFillerMock.VerifyAll();
}
public async Task AdministrationControllerTest_CreateRegionsAsync()
{
// Arrange
var controller = new AdministrationController(service);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
var model = new Region()
{
RegionID = 5,
RegionDescription = "Acme Region"
};
var result = await controller.CreateRegion(model);
// Assert
var response = default(ISingleModelResponse <Region>);
result.TryGetContentValue(out response);
Assert.IsNotNull(response.Model.RegionID);
}
public async Task AdministrationControllerTest_CreateCategoryAsync()
{
// Arrange
var controller = new AdministrationController(service);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
var model = new Category()
{
CategoryName = "Acme Category",
Description = "Acme category description"
};
var result = await controller.CreateCategory(model);
// Assert
var response = default(ISingleModelResponse <CategoryViewModel>);
result.TryGetContentValue(out response);
Assert.IsNotNull(response.Model.CategoryID);
}
public async Task AdministrationControllerTest_UpdateCategoryAsync()
{
// Arrange
var controller = new AdministrationController(service);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
var model = new Category()
{
CategoryName = "Acme 2",
Description = "22445 77990"
};
var result = await controller.UpdateCategory(8, model);
// Assert
var value = default(ISingleModelResponse <CategoryViewModel>);
result.TryGetContentValue(out value);
Assert.IsTrue(value.Message == "Record updated successfully");
}
public async Task Administration_GetOrdersAsync()
{
// Arrange
var controller = new AdministrationController(service);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
var orderID = default(Int32?);
var customerID = String.Empty;
var employeeID = default(Int32?);
var shipperID = default(Int32?);
// Act
var result = await controller.GetOrders(orderID, customerID, employeeID, shipperID);
// Assert
var value = default(IComposedModelResponse <OrderSummaryViewModel>);
result.TryGetContentValue(out value);
Assert.IsNotNull(value.Model);
Console.WriteLine("Model.Count: {0}", value.Model.Count());
}
public async Task Administration_CreateShipperAsync()
{
// Arrange
var controller = new AdministrationController(service);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
var model = new Shipper()
{
CompanyName = "Acme",
Phone = "12345 67890"
};
var result = await controller.CreateShipper(model);
// Assert
var response = default(ISingleModelResponse <Shipper>);
result.TryGetContentValue(out response);
Assert.IsNotNull(response.Model.ShipperID);
}
public async Task Administration_UpdateShipperAsync()
{
// Arrange
var controller = new AdministrationController(service);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
var model = new Shipper()
{
CompanyName = "Acme 2",
Phone = "22445 77990"
};
var result = await controller.UpdateShipper(8, model);
// Assert
var value = default(ISingleModelResponse <Shipper>);
result.TryGetContentValue(out value);
Assert.IsTrue(value.Message == "Record updated successfully");
}
public void Doctors_DetailGrid()
{
//Arrange
var cRepository = new Mock <IClinicRepository>();
var controller = new AdministrationController(cRepository.Object);
var clinicId = 111;
var doctor1 = new User {
Id = 10,
FirstName = "First10",
LastName = "Last10",
Role = "Doctor",
Patients = new List <Patient> {
new Patient()
},
Login = "******",
Photo = new byte[] { 1, 2, 3 }
};
var doctor2 = new User {
Id = 20,
FirstName = "First20",
LastName = "Last20",
Role = "Supervisor",
Patients = new List <Patient> {
new Patient(), new Patient()
},
Login = "******",
Photo = new byte[] { 3, 4, 5 }
};
var clinic = new Clinic {
Id = clinicId, Caption = "Clinic111", Doctors = new List <User> {
doctor1, doctor2
}
};
cRepository.Setup(r => r.GetByKey(clinicId)).Returns(clinic);
//Act
var result = controller.ClinicDoctors(clinicId);
//Assert
Assert.That(result, Is.Not.Null);
Assert.That(result is PartialViewResult);
var viewResultBase = result as ViewResultBase;
Assert.That(viewResultBase.Model, Is.Not.Null);
Assert.That(viewResultBase.ViewName, Is.EqualTo("_ClinicDoctorsGrid"));
Assert.That(viewResultBase.Model is ClinicDetailsViewModel);
var model = viewResultBase.Model as ClinicDetailsViewModel;
Assert.That(model.Doctors, Is.Not.Null);
Assert.That(model.Doctors.Count, Is.EqualTo(2));
Assert.That(model.ClinicId, Is.EqualTo(111));
Assert.That(model.Doctors[0].ClinicId, Is.EqualTo(111));
Assert.That(model.Doctors[0].DoctorId, Is.EqualTo(10));
Assert.That(model.Doctors[0].FirstName, Is.EqualTo("First10"));
Assert.That(model.Doctors[0].LastName, Is.EqualTo("Last10"));
Assert.That(model.Doctors[0].Role, Is.EqualTo("Doctor"));
Assert.That(model.Doctors[0].PatientsCount, Is.EqualTo(1));
Assert.That(model.Doctors[0].Login, Is.EqualTo("login10"));
Assert.That(model.Doctors[0].Photo, Is.EqualTo(new byte[] { 1, 2, 3 }));
Assert.That(model.Doctors[1].ClinicId, Is.EqualTo(111));
Assert.That(model.Doctors[1].DoctorId, Is.EqualTo(20));
Assert.That(model.Doctors[1].FirstName, Is.EqualTo("First20"));
Assert.That(model.Doctors[1].LastName, Is.EqualTo("Last20"));
Assert.That(model.Doctors[1].Role, Is.EqualTo("Supervisor"));
Assert.That(model.Doctors[1].PatientsCount, Is.EqualTo(2));
Assert.That(model.Doctors[1].Login, Is.EqualTo("login20"));
Assert.That(model.Doctors[1].Photo, Is.EqualTo(new byte[] { 3, 4, 5 }));
cRepository.Verify(r => r.GetByKey(clinicId), Times.Once());
}
public void GetAllFriendListsAndFriendsTests_Should_RenderCorrectView_WithCorrectParameters()
{
var userServiceMocked = new Mock <IUserService>();
var groupsServiceMocked = new Mock <IGroupService>();
var friendListServiceMocked = new Mock <IFriendListService>();
var birthday = new DateTime(1994, 5, 5);
var friendList = new FriendsList()
{
Name = "testFriendList",
Friends = new List <Friend>()
{
new Friend()
{
Name = "testAuthor",
Birthday = birthday,
Gender = false
}
}
};
var friendListViewModel = new FriendsViewModel();
friendListViewModel.Name = "testFriendList";
friendListViewModel.Friends = new List <FriendViewModel>()
{
new FriendViewModel()
{
Name = "testAuthor",
Gender = false,
Birthday = birthday
}
};
friendListServiceMocked.Setup(m => m.GetAll())
.Returns(new List <FriendsList>()
{
friendList
});
var controller = new AdministrationController(groupsServiceMocked.Object,
friendListServiceMocked.Object, userServiceMocked.Object);
controller
.WithCallTo(m => m.GetAllFriendListsAndFriends())
.ShouldRenderDefaultView()
.WithModel <List <FriendsViewModel> >(viewModel =>
{
Assert.AreEqual(viewModel.First().Name,
friendListViewModel.Name);
Assert.AreEqual(viewModel.First().Friends.Count, 1);
Assert.AreEqual(viewModel.First().Friends.First()
.Birthday, friendListViewModel.Friends.First().Birthday);
Assert.AreEqual(viewModel.First().Friends.First()
.Name, friendListViewModel.Friends.First().Name);
Assert.AreEqual(viewModel.First().Friends.First()
.Gender, friendListViewModel.Friends.First().Gender);
});
}
public void Index_ShouldRender_ViewWithCorrectParameters()
{
var userServiceMocked = new Mock <IUserService>();
var groupsServiceMocked = new Mock <IGroupService>();
var friendListServiceMocked = new Mock <IFriendListService>();
groupsServiceMocked.Setup(m => m.GetAll())
.Returns(new List <Group>()
{
new Group()
{
Messages = new List <Message>()
{
new Message()
{
},
new Message()
{
}
}
}
});
friendListServiceMocked.Setup(m => m.GetAll())
.Returns(new List <FriendsList>()
{
new FriendsList()
{
Friends = new List <Friend>()
{
new Friend()
{
},
new Friend()
{
},
new Friend()
{
}
}
}
});
userServiceMocked.Setup(m => m.GetAll())
.Returns(new List <User>()
{
new User()
{
},
new User()
{
}
});
var controller = new AdministrationController(groupsServiceMocked.Object,
friendListServiceMocked.Object, userServiceMocked.Object);
var adminViewModel = new AdminDataInitalViewModel();
adminViewModel.FriendListsCount = 1;
adminViewModel.GroupsCount = 1;
adminViewModel.MessagesCount = 2;
adminViewModel.UsersCount = 2;
adminViewModel.FriendsCount = 3;
controller
.WithCallTo(m => m.Index())
.ShouldRenderDefaultView()
.WithModel <AdminDataInitalViewModel>(viewModel =>
{
Assert.AreEqual(viewModel.MessagesCount, adminViewModel.MessagesCount);
Assert.AreEqual(viewModel.GroupsCount, adminViewModel.GroupsCount);
Assert.AreEqual(viewModel.UsersCount, adminViewModel.UsersCount);
Assert.AreEqual(viewModel.FriendsCount, adminViewModel.FriendsCount);
Assert.AreEqual(viewModel.FriendListsCount, adminViewModel.FriendListsCount);
});
}
public void CreateDeleteUndoOrganization()
{
AdministrationController controller = new AdministrationController();
// todo
}
public void Index_ShouldCall_GetAllUsers_Once()
{
var userServiceMocked = new Mock <IUserService>();
var groupsServiceMocked = new Mock <IGroupService>();
var friendListServiceMocked = new Mock <IFriendListService>();
groupsServiceMocked.Setup(m => m.GetAll())
.Returns(new List <Group>()
{
new Group()
{
Messages = new List <Message>()
{
new Message()
{
},
new Message()
{
}
}
}
});
friendListServiceMocked.Setup(m => m.GetAll())
.Returns(new List <FriendsList>()
{
new FriendsList()
{
Friends = new List <Friend>()
{
new Friend()
{
},
new Friend()
{
},
new Friend()
{
}
}
}
});
userServiceMocked.Setup(m => m.GetAll())
.Returns(new List <User>()
{
new User()
{
},
new User()
{
}
});
var controller = new AdministrationController(groupsServiceMocked.Object,
friendListServiceMocked.Object, userServiceMocked.Object);
controller.Index();
userServiceMocked.Verify(m => m.GetAll(), Times.Once);
}
public void SetUp()
{
//Create controller
_controller = new AdministrationController();
}
