/// <summary>
/// Creates a new instance of MocksAndStubsContainer.
/// </summary>
/// <param name="useCacheMock">The 'Roadkill' MemoryCache is used by default, but as this is static it can have problems with
/// the test runner unless you clear the Container.MemoryCache on setup each time, but then doing that doesn't give a realistic
/// reflection of how the MemoryCache is used inside an ASP.NET environment.</param>
public MocksAndStubsContainer(bool useCacheMock = false)
{
ApplicationSettings = new ApplicationSettings();
ApplicationSettings.Installed = true;
ApplicationSettings.AttachmentsFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "attachments");
// Cache
MemoryCache = useCacheMock ? new CacheMock() : CacheMock.RoadkillCache;
ListCache = new ListCache(ApplicationSettings, MemoryCache);
SiteCache = new SiteCache(ApplicationSettings, MemoryCache);
PageViewModelCache = new PageViewModelCache(ApplicationSettings, MemoryCache);
// Repository
Repository = new RepositoryMock();
Repository.SiteSettings = new SiteSettings();
Repository.SiteSettings.MarkupType = "Creole";
PluginFactory = new PluginFactoryMock();
MarkupConverter = new MarkupConverter(ApplicationSettings, Repository, PluginFactory);
// Dependencies for PageService. Be careful to make sure the class using this Container isn't testing the mock.
SettingsService = new SettingsService(ApplicationSettings, Repository);
UserService = new UserServiceMock(ApplicationSettings, Repository);
UserContext = new UserContext(UserService);
SearchService = new SearchServiceMock(ApplicationSettings, Repository, PluginFactory);
SearchService.PageContents = Repository.PageContents;
SearchService.Pages = Repository.Pages;
HistoryService = new PageHistoryService(ApplicationSettings, Repository, UserContext, PageViewModelCache, PluginFactory);
PageService = new PageService(ApplicationSettings, Repository, SearchService, HistoryService, UserContext, ListCache, PageViewModelCache, SiteCache, PluginFactory);
// EmailTemplates
EmailClient = new EmailClientMock();
}
public void Setup()
{
// WikiController setup (use WikiController as it's the one typically used by views)
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_context = _container.UserContext;
_repository = _container.Repository;
_pluginFactory = _container.PluginFactory;
_settingsService = _container.SettingsService;
_userService = _container.UserService;
_historyService = _container.HistoryService;
_pageService = _container.PageService;
_wikiController = new WikiController(_applicationSettings, _userService, _pageService, _context, _settingsService);
_wikiController.SetFakeControllerContext("~/wiki/index/1");
// HtmlHelper setup
var viewDataDictionary = new ViewDataDictionary();
_viewContext = new ViewContext(_wikiController.ControllerContext, new Mock<IView>().Object, viewDataDictionary, new TempDataDictionary(), new StringWriter());
var mockViewDataContainer = new Mock<IViewDataContainer>();
mockViewDataContainer.Setup(v => v.ViewData).Returns(viewDataDictionary);
_htmlHelper = new HtmlHelper(_viewContext, mockViewDataContainer.Object);
}
public async void Should_return_BadRequest_when_model_is_null()
{
//Arrange
UserUpdate user = null;
var userId = 1;
var returnExistValue = true;
var key = "Me_StatusCode_400_BadRequest";
var localizedString = new LocalizedString(key, "Bad Request");
LocalizerMock
.Setup(_ => _[key])
.Returns(localizedString);
// Service
UserServiceMock.Setup(x => x.IsExistAsync(userId)).ReturnsAsync(returnExistValue);
// set header values
ControllerUnderTest.ControllerContext.HttpContext.Request.Headers.Add("id", userId.ToString());
//Act
var result = await ControllerUnderTest.Update(user);
//Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public async void Should_return_CreatedResult_when_model_Is_valid()
{
// Arrange
var returnExistValue = true;
var address = AddressData;
int userId = 1;
var resultObject = new Address
{
Address1 = "1601 Hood Avenue",
Address2 = "dolore in adipisicing et",
City = "San Diego",
CountryCode = "11",
PinCode = "92103",
StateId = 1
};
AddressServiceMock
.Setup(x => x.CreateAsync(userId, address))
.ReturnsAsync(resultObject);
UserServiceMock
.Setup(x => x.IsExistAsync(userId))
.ReturnsAsync(true);
//Act
UserServiceMock.Setup(x => x.IsExistAsync(userId)).ReturnsAsync(returnExistValue);
var result = await ControllerUnderTest.CreateAddress(userId, address);
//Assert
var okResult = Assert.IsType <CreatedResult>(result);
Assert.Same(resultObject, okResult.Value);
}
public void Setup()
{
_container = new MocksAndStubsContainer();
_userService = _container.UserService;
_userController = new UserController(_userService);
}
public void Setup()
{
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_applicationSettings.ConnectionString = "connstring";
_context = _container.UserContext;
_repository = _container.Repository;
_pluginFactory = _container.PluginFactory;
_settingsService = _container.SettingsService;
_userService = _container.UserService;
_historyService = _container.HistoryService;
_pageService = _container.PageService;
_listCache = _container.ListCache;
_pageViewModelCache = _container.PageViewModelCache;
// User setup
_editorUser = new User();
_editorUser.Id = Guid.NewGuid();
_editorUser.Email = EditorEmail;
_editorUser.Username = EditorUsername;
_editorUser.IsAdmin = false;
_editorUser.IsEditor = true;
_adminUser = new User();
_adminUser.Id = Guid.NewGuid();
_adminUser.Email = AdminEmail;
_adminUser.Username = AdminUsername;
_adminUser.IsAdmin = true;
_adminUser.IsEditor = true;
_userService.Users.Add(_editorUser);
_userService.Users.Add(_adminUser);
SetUserContext(_adminUser);
}
public async Task Should_return_OkObjectResult_with_users()
{
//Arrange
var expectedUsers = new User[]
{
new User {
Name = "Gabriel Meyer", Email = "*****@*****.**"
},
new User {
Name = "Renato Rezende", Email = "*****@*****.**"
}
};
UserServiceMock
.Setup(x => x.GetAllAsync())
.ReturnsAsync(expectedUsers);
//Act
var result = await ControllerUnderTest.GetAllAsync();
//Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(expectedUsers, okResult.Value);
}
public void Setup()
{
// WikiController setup (use WikiController as it's the one typically used by views)
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_context = _container.UserContext;
_repository = _container.Repository;
_pluginFactory = _container.PluginFactory;
_settingsService = _container.SettingsService;
_userService = _container.UserService;
_historyService = _container.HistoryService;
_pageService = _container.PageService;
_wikiController = new WikiController(_applicationSettings, _userService, _pageService, _context, _settingsService);
_wikiController.SetFakeControllerContext("~/wiki/index/1");
// HtmlHelper setup
var viewDataDictionary = new ViewDataDictionary();
_viewContext = new ViewContext(_wikiController.ControllerContext, new Mock <IView>().Object, viewDataDictionary, new TempDataDictionary(), new StringWriter());
var mockViewDataContainer = new Mock <IViewDataContainer>();
mockViewDataContainer.Setup(v => v.ViewData).Returns(viewDataDictionary);
_htmlHelper = new HtmlHelper(_viewContext, mockViewDataContainer.Object);
}
public async Task WhenAddFailsReturnsMessage()
{
var user = TestUtils.GetRandomUser();
var lobbyMessage = new LobbyMessage
{
Id = 1,
MessageDateTime = DateTime.UtcNow,
MessageText = "Test Message",
Sender = user
};
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(user);
MessageServiceMock.Setup(ms => ms.AddMessageAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(lobbyMessage);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <AddMessageResponse>(result);
Assert.IsTrue(response.Success);
Assert.AreEqual(lobbyMessage.Id, response.NewMessage.Id);
Assert.AreEqual(lobbyMessage.MessageText, response.NewMessage.Message);
Assert.AreEqual(lobbyMessage.MessageDateTime, response.NewMessage.Time);
Assert.AreEqual(lobbyMessage.Sender.UserName, response.NewMessage.User);
SubscriberMock.Verify(s => s.PublishAsync(It.IsAny <RedisChannel>(), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}
public void Setup()
{
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_context = _container.UserContext;
_repository = _container.Repository;
_settingsService = _container.SettingsService;
_userService = _container.UserService;
_pageCache = _container.PageViewModelCache;
_listCache = _container.ListCache;
_siteCache = _container.SiteCache;
_cache = _container.MemoryCache;
_container.ClearCache();
_pageService = _container.PageService;
_wikiImporter = new WikiImporterMock();
_pluginFactory = _container.PluginFactory;
_searchService = _container.SearchService;
// There's no point mocking WikiExporter (and turning it into an interface) as
// a lot of usefulness of these tests would be lost when creating fake Streams and zip files.
_wikiExporter = new WikiExporter(_applicationSettings, _pageService, _repository, _pluginFactory);
_wikiExporter.ExportFolder = AppDomain.CurrentDomain.BaseDirectory;
_toolsController = new ToolsController(_applicationSettings, _userService, _settingsService, _pageService,
_searchService, _context, _listCache, _pageCache, _wikiImporter,
_repository, _pluginFactory, _wikiExporter);
}
public void GetContactsUsers_Tests()
{
#region Variables
var contactIds = new List <int> {
1, 2, 3
};
var masterVendorId = 1;
#endregion
#region Data SetUp
#region User
var lstUser = new List <MRMUser>()
{
new MRMUser
{
Id = 1,
FirstName = "User1",
LastName = "Last1",
MasterVendorId = 1,
EmailAddress = "*****@*****.**"
},
new MRMUser
{
Id = 2,
FirstName = "User2",
LastName = "Last2",
MasterVendorId = 1,
EmailAddress = "*****@*****.**"
},
new MRMUser
{
Id = 3,
FirstName = "User3",
LastName = "Last3",
MasterVendorId = 1,
EmailAddress = "*****@*****.**"
}
};
#endregion
#endregion
#region Mock
mockUserRepository.Setup(x => x.GetMany(It.IsAny <Expression <Func <MRMUser, bool> > >())).Returns(lstUser.AsEnumerable());
#endregion
#region Services
var userService = new UserServiceMock(
_userRepository: mockUserRepository.Object);
#endregion
#region Asserts
var results = userService.GetContactsUsers(contactIds, masterVendorId).ToList();
Assert.IsTrue(results != null);
Assert.IsTrue(results.Count == 3);
#endregion
}
public async Task WhenUserNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync((Data.Models.GametekiUser)null);
var result = await Controller.UpdateUser(TestUser, new ApiUserAdmin());
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenTokenNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetRefreshTokenByIdAsync(It.IsAny <int>()))
.ReturnsAsync((RefreshToken)null);
var result = await Controller.DeleteUserSession(TestUser, 1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenUsernameNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync((GametekiUser)null);
var result = await Controller.UpdateProfile(TestUser, new UpdateProfileRequest());
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenMessageNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync((LobbyMessage)null);
var result = await Controller.RemoveMessage(1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenUsernameNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync((GametekiUser)null);
var result = await Controller.RemoveBlockListEntry(TestUser, "Blocked");
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenLoginFailsReturnsUnauthorised()
{
UserServiceMock
.Setup(us => us.LoginUserAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync((LoginResult)null);
var result = await Controller.Login(new LoginRequest());
Assert.IsInstanceOfType(result, typeof(UnauthorizedResult));
}
public InvestmentServiceTests()
{
_mapperMock = new AutoMapperMock();
_userService = new UserServiceMock();
_context = SeedData(5);
_investmentRepository = new InvestmentRepositoryMock(_context);
_investmentService = new InvestmentService(_investmentRepository, _userService.Object, _mapperMock.Object);
}
public async Task WhenUserNotFoundReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync((GametekiUser)null);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public UserControllerTests()
{
_userService = new UserServiceMock();
_emailSender = new EmailSenderMock();
_controller = new UserController(_userService.Object, _emailSender.Object)
{
Url = new UrlHelperMock("/RegistrationSuccess/").Object,
ControllerContext = { HttpContext = new DefaultHttpContext() }
};
}
public async Task WhenValidateSucceedsReturnsSuccessResponse()
{
UserServiceMock.Setup(us => us.ValidateUserAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(true);
var result = await Controller.ActivateAccount(new VerifyAccountRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
}
public void CorrectlyAssignContextValue_WhenParamsAreValid()
{
// Arrange
var contextMock = new Mock <ITravelGuideContext>();
// Act
var service = new UserServiceMock(contextMock.Object);
// Assert
Assert.AreSame(contextMock.Object, service.Context);
}
public async Task WhenLogoutSucceedsReturnsSuccessResponse()
{
UserServiceMock.Setup(us => us.LogoutUserAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(true);
var result = await Controller.Logout(new RefreshTokenRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
}
public async Task WhenAddFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.AddMessageAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync((LobbyMessage)null);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenGetUsernameFailsReturnsFailureResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync((GametekiUser)null);
var result = await Controller.CheckAuth();
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenUpdateFailsReturnsFailureResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
UserServiceMock.Setup(us => us.UpdateUserAsync(It.IsAny <Data.Models.GametekiUser>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed());
var result = await Controller.UpdateUser(TestUser, new ApiUserAdmin());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenGetUsernameSucceedsReturnsSuccessResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync(TestUtils.GetRandomUser());
var result = await Controller.CheckAuth();
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
}
public void Setup()
{
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_context = _container.UserContext;
_userService = _container.UserService;
_applicationSettings.AdminRoleName = "Admin";
_applicationSettings.EditorRoleName = "Editor";
}
public async Task WhenDeleteTokenFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetRefreshTokenByIdAsync(It.IsAny <int>()))
.ReturnsAsync(new RefreshToken());
UserServiceMock.Setup(us => us.DeleteRefreshTokenAsync(It.IsAny <RefreshToken>())).ReturnsAsync(false);
var result = await Controller.DeleteUserSession(TestUser, 1);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public void Setup()
{
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_userContext = _container.UserContext;
_userService = _container.UserService;
_repositoryMock = _container.Repository;
_userService = _container.UserService;
_userController = new UserController(_applicationSettings, _userService, _userContext);
}
public async Task WhenRemoveFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync(new LobbyMessage());
MessageServiceMock.Setup(ms => ms.UpdateMessageAsync(It.IsAny <LobbyMessage>())).ReturnsAsync(false);
var result = await Controller.RemoveMessage(1);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public void Setup()
{
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_userContext = _container.UserContext;
_userService = _container.UserService;
_repositoryMock = _container.Repository;
_pageService = _container.PageService;
_pagesController = new PagesController(_pageService, _applicationSettings, _userService, _userContext);
}
public void Setup()
{
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_context = _container.UserContext;
_repository = _container.Repository;
_userService = _container.UserService;
_userService.Users.Add(new User() { Email = "*****@*****.**" });
_userViewModel = new UserViewModel(_applicationSettings, _userService);
}
public void Setup()
{
// WikiController setup (use WikiController as it's the one typically used by views)
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_context = _container.UserContext;
_repository = _container.Repository;
_pluginFactory = _container.PluginFactory;
_settingsService = _container.SettingsService;
_siteSettings = _settingsService.GetSiteSettings();
_siteSettings.Theme = "Mediawiki";
_userService = _container.UserService;
_historyService = _container.HistoryService;
_pageService = _container.PageService;
_wikiController = new WikiController(_applicationSettings, _userService, _pageService, _context, _settingsService);
_wikiController.SetFakeControllerContext("~/wiki/index/1");
_urlHelper = _wikiController.Url;
}
public void Setup()
{
_container = new MocksAndStubsContainer();
_applicationSettings = _container.ApplicationSettings;
_context = _container.UserContext;
_repository = _container.Repository;
_pluginFactory = _container.PluginFactory;
_settingsService = _container.SettingsService;
_userService = _container.UserService;
_historyService = _container.HistoryService;
_pageService = _container.PageService;
_attachmentFileHandler = new AttachmentFileHandler(_applicationSettings);
try
{
// Delete any existing attachments folder
DirectoryInfo directoryInfo = new DirectoryInfo(_applicationSettings.AttachmentsFolder);
if (directoryInfo.Exists)
{
directoryInfo.Attributes = FileAttributes.Normal;
directoryInfo.Delete(true);
}
Directory.CreateDirectory(_applicationSettings.AttachmentsFolder);
}
catch (IOException e)
{
Assert.Fail("Unable to delete the attachments folder " + _applicationSettings.AttachmentsFolder + ", does it have a lock/explorer window open, or Mercurial open?" + e.ToString());
}
catch (ArgumentException e)
{
Assert.Fail("Unable to delete the attachments folder " + _applicationSettings.AttachmentsFolder + ", is EasyMercurial open?" + e.ToString());
}
_filesController = new FileManagerController(_applicationSettings, _userService, _context, _settingsService, _attachmentFileHandler);
_mvcMockContainer = _filesController.SetFakeControllerContext();
}
