public void Setup() { _container = new MocksAndStubsContainer(); _applicationSettings = _container.ApplicationSettings; _context = _container.UserContext; _settingsRepository = _container.SettingsRepository; _userRepository = _container.UserRepository; _pageRepository = _container.PageRepository; _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, _settingsRepository, _pageRepository, _userRepository, _pluginFactory); _wikiExporter.ExportFolder = AppDomain.CurrentDomain.BaseDirectory; _toolsController = new ToolsController(_applicationSettings, _userService, _settingsService, _pageService, _searchService, _context, _listCache, _pageCache, _wikiImporter, _pluginFactory, _wikiExporter); }
public ConfigurationTesterController(ApplicationSettings appSettings, IUserContext userContext, ConfigReaderWriter configReaderWriter, IActiveDirectoryProvider activeDirectoryProvider) { _applicationSettings = appSettings; _userContext = userContext; _configReaderWriter = configReaderWriter; _activeDirectoryProvider = activeDirectoryProvider; }
/// <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 shoulddeserializewhitelistfromgeneratedxmlfile() { // Arrange string whitelistFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "whitelistgenerated.xml"); ApplicationSettings settings = new ApplicationSettings(); settings.HtmlElementWhiteListPath = whitelistFile; using (FileStream stream = new FileStream(whitelistFile, FileMode.Create, FileAccess.Write)) { XmlSerializer serializer = new XmlSerializer(typeof(HtmlWhiteList)); List<HtmlElement> list = new List<HtmlElement>(); list.Add(new HtmlElement("blah", new string[] { "id", "class" })); list.Add(new HtmlElement("test", new string[] { "href" })); HtmlWhiteList whiteList = new HtmlWhiteList(); whiteList.ElementWhiteList = list; serializer.Serialize(stream, whiteList); } string htmlFragment = "<test href=\"http://www.google.com\">link</test> <blah id=\"myid\" class=\"class1 class2\">somediv</blah><a href=\"test\">test</a>"; // Act MarkupSanitizer sanitizer = new MarkupSanitizer(settings); sanitizer.SetWhiteListCacheKey("ShouldDeserializeWhiteListFromGeneratedXmlFile"); string actual = sanitizer.SanitizeHtml(htmlFragment); // Assert string expected = "<test href=\"http://www.google.com\">link</test> <blah id=\"myid\" class=\"class1 class2\">somediv</blah>"; Assert.That(actual, Is.EqualTo(expected).IgnoreCase); }
private void MockServiceLocator() { var settings = new ApplicationSettings(); var configReader = new ConfigReaderWriterStub(); configReader.ApplicationSettings = settings; var registry = new RoadkillRegistry(configReader); var container = new Container(registry); container.Configure(x => { x.Scan(a => a.AssemblyContainingType<TestHelpers>()); x.For<IPageRepository>().Use(new PageRepositoryMock()); x.For<IUserContext>().Use(new UserContextStub()); }); LocatorStartup.Locator = new StructureMapServiceLocator(container, false); DependencyResolver.SetResolver(LocatorStartup.Locator); var all = container.Model.AllInstances.OrderBy(t => t.PluginType.Name) .Select(t => String.Format("{0}:{1}", t.PluginType.Name, t.ReturnedType.AssemblyQualifiedName)); Console.WriteLine(String.Join("\n", all)); }
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 void Setup() { _settings = new ApplicationSettings(); _settings.AttachmentsFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Attachments"); _attachmentPathUtil = new AttachmentPathUtil(_settings); try { // Delete any existing attachments folder // Remove the files 1st if (Directory.Exists(_settings.AttachmentsFolder)) { DirectoryInfo directoryInfo = new DirectoryInfo(_settings.AttachmentsFolder); foreach (FileInfo file in directoryInfo.GetFiles()) { File.Delete(file.FullName); } if (directoryInfo.Exists) { directoryInfo.Attributes = FileAttributes.Normal; directoryInfo.Delete(true); } } Directory.CreateDirectory(_settings.AttachmentsFolder); } catch (IOException e) { Assert.Fail("Unable to delete the attachments folder " + _settings.AttachmentsFolder + ", does it have a lock?" + e.ToString()); } }
public void Setup() { _container = new MocksAndStubsContainer(); _applicationSettings = _container.ApplicationSettings; _settingsService = _container.SettingsService; _fileService = new LocalFileService(_applicationSettings, _settingsService); 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()); } }
public UpgradeController(ApplicationSettings settings, IRepository repository, UserServiceBase userService, IUserContext context, SettingsService settingsService, ConfigReaderWriter configReaderWriter) : base(settings, userService, context, settingsService) { _repository = repository; _configReaderWriter = configReaderWriter; }
public void Internal_Links_Should_Resolve_With_Id() { // Bug #87 // Arrange Page page = new Page() { Id = 1, Title = "My first page"}; RepositoryMock repositoryStub = new RepositoryMock(); repositoryStub.AddNewPage(page, "My first page", "admin", DateTime.UtcNow); repositoryStub.SiteSettings = new SiteSettings() { MarkupType = "Markdown" }; ApplicationSettings settings = new ApplicationSettings(); settings.Installed = true; settings.UpgradeRequired = false; UrlResolverMock resolver = new UrlResolverMock(); resolver.InternalUrl = "blah"; MarkupConverter converter = new MarkupConverter(settings, repositoryStub, _pluginFactory); converter.UrlResolver = resolver; string markdownText = "[Link](My-first-page)"; string invalidMarkdownText = "[Link](My first page)"; // Act string expectedHtml = "<p><a href=\"blah\">Link</a></p>\n"; string expectedInvalidLinkHtml = "<p>[Link](My first page)</p>\n"; string actualHtml = converter.ToHtml(markdownText); string actualHtmlInvalidLink = converter.ToHtml(invalidMarkdownText); // Assert Assert.That(actualHtml, Is.EqualTo(expectedHtml)); Assert.That(actualHtmlInvalidLink, Is.EqualTo(expectedInvalidLinkHtml)); }
public void Images_Should_Support_Dimensions() { // Arrange Page page = new Page() { Id = 1, Title = "My first page" }; RepositoryMock repositoryStub = new RepositoryMock(); repositoryStub.AddNewPage(page, "My first page", "admin", DateTime.UtcNow); repositoryStub.SiteSettings = new SiteSettings() { MarkupType = "Markdown" }; ApplicationSettings settings = new ApplicationSettings(); settings.Installed = true; settings.UpgradeRequired = false; MarkupConverter converter = new MarkupConverter(settings, repositoryStub, _pluginFactory); string markdownText = "Here is an image:![Image](/Image1.png) \n\n" + "And another with equal dimensions ![Square](/Image1.png =250x) \n\n" + "And this one is a rectangle ![Rectangle](/Image1.png =250x350)"; string expectedHtml = "<p>Here is an image:<img src=\"/Attachments/Image1.png\" border=\"0\" alt=\"Image\" width=\"\" height=\"\" /> </p>\n\n" + "<p>And another with equal dimensions <img src=\"/Attachments/Image1.png\" border=\"0\" alt=\"Square\" width=\"250px\" height=\"\" /> </p>\n\n" + "<p>And this one is a rectangle <img src=\"/Attachments/Image1.png\" border=\"0\" alt=\"Rectangle\" width=\"250px\" height=\"350px\" /></p>\n"; // Act string actualHtml = converter.ToHtml(markdownText); // Assert Assert.That(actualHtml, Is.EqualTo(expectedHtml)); }
public WikiExporter(ApplicationSettings applicationSettings, PageService pageService, ISettingsRepository settingsRepository, IPageRepository pageRepository, IUserRepository userRepository, IPluginFactory pluginFactory) { if (applicationSettings == null) throw new ArgumentNullException(nameof(applicationSettings)); if (pageService == null) throw new ArgumentNullException(nameof(pageService)); if (settingsRepository == null) throw new ArgumentNullException(nameof(settingsRepository)); if (pageRepository == null) throw new ArgumentNullException(nameof(pageRepository)); if (userRepository == null) throw new ArgumentNullException(nameof(userRepository)); if (pluginFactory == null) throw new ArgumentNullException(nameof(pluginFactory)); _applicationSettings = applicationSettings; _pageService = pageService; _sqlExportBuilder = new SqlExportBuilder(settingsRepository, userRepository, pageRepository, pluginFactory); ExportFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data", "Export"); }
public void Setup() { _container = new MocksAndStubsContainer(); _applicationSettings = _container.ApplicationSettings; _applicationSettings.LdapConnectionString = _ldapString; _applicationSettings.LdapUsername = _username; _applicationSettings.LdapPassword = _password; _applicationSettings.AdminRoleName = _adminsGroupName; _applicationSettings.EditorRoleName = _editorsGroupName; _repository = _container.Repository; List<IPrincipalDetails> adminUsers = new List<IPrincipalDetails>(); adminUsers.Add(new MockPrincipal() { SamAccountName = "admin1" }); adminUsers.Add(new MockPrincipal() { SamAccountName = "admin2" }); List<IPrincipalDetails> editorUsers = new List<IPrincipalDetails>(); editorUsers.Add(new MockPrincipal() { SamAccountName = "editor1" }); editorUsers.Add(new MockPrincipal() { SamAccountName = "editor2" }); _adProviderMock = new Mock<IActiveDirectoryProvider>(); _adProviderMock.Setup(x => x.GetMembers(_domainPath, _username, _password, _adminsGroupName)).Returns(adminUsers); _adProviderMock.Setup(x => x.GetMembers(_domainPath, _username, _password, _editorsGroupName)).Returns(editorUsers); _userService = new ActiveDirectoryUserService(_applicationSettings, _repository, _adProviderMock.Object); }
public void Code_Blocks_Should_Allow_Quotes() { // Issue #82 // Arrange Page page = new Page() { Id = 1, Title = "My first page" }; RepositoryMock repositoryStub = new RepositoryMock(); repositoryStub.AddNewPage(page, "My first page", "admin", DateTime.UtcNow); repositoryStub.SiteSettings = new SiteSettings() { MarkupType = "Markdown" }; ApplicationSettings settings = new ApplicationSettings(); settings.Installed = true; settings.UpgradeRequired = false; MarkupConverter converter = new MarkupConverter(settings, repositoryStub, _pluginFactory); string markdownText = "Here is some `// code with a 'quote' in it and another \"quote\"`\n\n" + " var x = \"some tabbed code\";\n\n"; // 2 line breaks followed by 4 spaces (tab stop) at the start indicates a code block string expectedHtml = "<p>Here is some <code>// code with a 'quote' in it and another \"quote\"</code></p>\n\n" + "<pre><code>var x = \"some tabbed code\";\n" + "</code></pre>\n"; // Act string actualHtml = converter.ToHtml(markdownText); // Assert Assert.That(actualHtml, Is.EqualTo(expectedHtml)); }
/// <summary> /// Creates a new markdown parser which handles the image and link parsing by the various different /// markdown format parsers. /// </summary> /// <returns>An <see cref="IMarkupParser"/> for Creole,Markdown or Media wiki formats.</returns> public MarkupConverter(ApplicationSettings settings, ISettingsRepository settingsRepository, IPageRepository pageRepository, IPluginFactory pluginFactory) { _externalLinkPrefixes = new List<string>() { "http://", "https://", "www.", "mailto:", "#", "tag:" }; _pluginFactory = pluginFactory; _settingsRepository = settingsRepository; _pageRepository = pageRepository; _applicationSettings = settings; // Create the UrlResolver for all wiki urls HttpContextBase httpContext = null; if (HttpContext.Current != null) httpContext = new HttpContextWrapper(HttpContext.Current); UrlResolver = new UrlResolver(httpContext); if (!_applicationSettings.Installed) { // Skip the chain of creation, as the markup converter isn't needed but is created by // StructureMap - this is required for installation return; } CreateParserForMarkupType(); }
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; _pageRepository = _container.PageRepository; _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); }
/// <summary> /// Constructor for the file manager. /// </summary> /// <remarks>This action requires editor rights.</remarks> public FileManagerController(ApplicationSettings settings, UserServiceBase userManager, IUserContext context, SettingsService settingsService, AttachmentFileHandler attachment) : base(settings, userManager, context, settingsService) { _attachmentHandler = attachment; _attachmentPathUtil = new AttachmentPathUtil(settings); }
public void Should_Replace_Known_Tokens_When_Logged_In_As_Editor() { // Arrange string menuMarkup = "* %categories%\r\n\r\n%allpages%\r\n%mainpage%\r\n%newpage%\r\n%managefiles%\r\n%sitesettings%\r\n"; string expectedHtml = "<ul><li><a href=\"/pages/alltags\">Categories</a></li></ul>" + "<a href=\"/pages/allpages\">All pages</a>" + "<a href=\"/\">Main Page</a>" + "<a href=\"/pages/new\">New page</a><a href=\"/filemanager\">Manage files</a>"; RepositoryMock repository = new RepositoryMock(); repository.SiteSettings = new SiteSettings(); repository.SiteSettings.MarkupType = "Markdown"; repository.SiteSettings.MenuMarkup = menuMarkup; UserContextStub userContext = new UserContextStub(); userContext.IsAdmin = false; userContext.IsLoggedIn = true; ApplicationSettings applicationSettings = new ApplicationSettings(); applicationSettings.Installed = true; CacheMock cache = new CacheMock(); SiteCache siteCache = new SiteCache(applicationSettings, cache); MarkupConverter converter = new MarkupConverter(applicationSettings, repository, _pluginFactory); MenuParser parser = new MenuParser(converter, repository, siteCache, userContext); // Act string actualHtml = parser.GetMenu(); // Assert Assert.That(actualHtml, Is.EqualTo(expectedHtml), actualHtml); }
public PageHistoryService(ApplicationSettings settings, IRepository repository, IUserContext context, PageViewModelCache pageViewModelCache, IPluginFactory pluginFactory) : base(settings, repository) { _markupConverter = new MarkupConverter(settings, repository, pluginFactory); _context = context; _pageViewModelCache = pageViewModelCache; }
public UserController(ApplicationSettings settings, UserServiceBase userManager, IUserContext context, SettingsService settingsService, SignupEmail signupEmail, ResetPasswordEmail resetPasswordEmail) : base(settings, userManager, context, settingsService) { _signupEmail = signupEmail; _resetPasswordEmail = resetPasswordEmail; }
public SettingsController(ApplicationSettings settings, UserServiceBase userManager, SettingsService settingsService, IUserContext context, SiteCache siteCache, ConfigReaderWriter configReaderWriter) : base(settings, userManager, context, settingsService) { _settingsService = settingsService; _siteCache = siteCache; _configReaderWriter = configReaderWriter; }
public ControllerBase(ApplicationSettings settings, UserServiceBase userService, IUserContext context, SettingsService settingsService) { ApplicationSettings = settings; UserService = userService; Context = context; SettingsService = settingsService; }
public HomeController(ApplicationSettings settings, UserServiceBase userManager, MarkupConverter markupConverter, PageService pageService, SearchService searchService, IUserContext context, SettingsService settingsService) : base(settings, userManager, context, settingsService) { _markupConverter = markupConverter; _searchService = searchService; PageService = pageService; }
public void SetUp() { ApplicationSettings = new ApplicationSettings() { ConnectionString = ConnectionString, DataStoreType = DataStoreType }; Repository = GetRepository(); Repository.Startup(ApplicationSettings.DataStoreType, ApplicationSettings.ConnectionString, false); Repository.Install(ApplicationSettings.DataStoreType, ApplicationSettings.ConnectionString, false); }
public void Setup() { _applicationSettings = new ApplicationSettings(); _applicationSettings.AttachmentsFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Unit", "Attachments"); _applicationSettings.AttachmentsRoutePath = "Attachments"; _fileService = new LocalFileService(_applicationSettings, new SettingsService(_applicationSettings,null)); }
public void Setup() { _container = new MocksAndStubsContainer(); _applicationSettings = _container.ApplicationSettings; _settingsRepository = _container.SettingsRepository; _emailClientMock = _container.EmailClient; }
public void Three_Constructor_Argument_Should_Throw_If_Installed_With_No_Connection_String() { // Arrange, act, assert ApplicationSettings settings = new ApplicationSettings(); settings.Installed = true; DependencyManager container = new DependencyManager(settings, new RepositoryMock(), new UserContext(null)); }
public RelController(ApplicationSettings settings, UserServiceBase userManager, SettingsService settingsService, IRelService relService, SearchService searchService, PageHistoryService historyService, IUserContext context) : base(settings, userManager, context, settingsService) { _settingsService = settingsService; _relService = relService; }
public DependencyManager(ApplicationSettings applicationSettings) { if (applicationSettings == null) throw new IoCException("The ApplicationSettings parameter is null", null); _applicationSettings = applicationSettings; _useCustomInstances = false; }
public void Setup() { _container = new MocksAndStubsContainer(); _applicationSettings = _container.ApplicationSettings; _repository = _container.Repository; _settingsService = _container.SettingsService; }