Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        /// <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();
        }
Ejemplo n.º 3
0
        public void Setup()
        {
            _container = new MocksAndStubsContainer();

            _applicationSettings           = _container.ApplicationSettings;
            _applicationSettings.Installed = false;

            _context            = _container.UserContext;
            _repository         = _container.Repository;
            _pluginFactory      = _container.PluginFactory;
            _settingsService    = _container.SettingsService;
            _userService        = _container.UserService;
            _historyService     = _container.HistoryService;
            _pageService        = _container.PageService;
            _searchService      = _container.SearchService;
            _configReaderWriter = new ConfigReaderWriterStub();

            _installController = new InstallController(_applicationSettings, _userService, _pageService, _searchService, _repository, _settingsService, _context, _configReaderWriter);
        }
Ejemplo n.º 4
0
        public void Setup()
        {
            _container = new MocksAndStubsContainer();

            _applicationSettings = _container.ApplicationSettings;
            _repository          = _container.Repository;
            _pluginFactory       = _container.PluginFactory;
            _settingsService     = _container.SettingsService;
            _userService         = _container.UserService;
            _historyService      = _container.HistoryService;
            _markupConverter     = _container.MarkupConverter;
            _searchService       = _container.SearchService;

            // Use a stub instead of the MocksAndStubsContainer's default
            _contextStub = new UserContextStub();

            // Customise the page service so we can verify what was called
            _pageServiceMock = new Mock <IPageService>();
            _pageServiceMock.Setup(x => x.GetMarkupConverter()).Returns(new MarkupConverter(_applicationSettings, _repository, _pluginFactory));
            _pageServiceMock.Setup(x => x.GetById(It.IsAny <int>(), false)).Returns <int, bool>((int id, bool loadContent) =>
            {
                Page page = _repository.GetPageById(id);
                return(new PageViewModel(page));
            });
            _pageServiceMock.Setup(x => x.GetById(It.IsAny <int>(), true)).Returns <int, bool>((int id, bool loadContent) =>
            {
                PageContent content = _repository.GetLatestPageContent(id);

                if (content != null)
                {
                    return(new PageViewModel(content, _markupConverter));
                }
                else
                {
                    return(null);
                }
            });
            _pageServiceMock.Setup(x => x.FindByTag(It.IsAny <string>()));
            _pageService = _pageServiceMock.Object;

            _pagesController = new PagesController(_applicationSettings, _userService, _settingsService, _pageService, _searchService, _historyService, _contextStub);
            _mocksContainer  = _pagesController.SetFakeControllerContext();
        }
Ejemplo n.º 5
0
        public void Setup()
        {
            _container = new MocksAndStubsContainer();

            _applicationSettings = _container.ApplicationSettings;
            _context             = _container.UserContext;
            _settingsService     = _container.SettingsService;
            _userService         = _container.UserService;

            _controller = new ControllerBaseStub(_applicationSettings, _userService, _context, _settingsService);
            MvcMockContainer container = _controller.SetFakeControllerContext("~/");

            // Used by InstallController
            _repository         = _container.Repository;
            _pluginFactory      = _container.PluginFactory;
            _historyService     = _container.HistoryService;
            _pageService        = _container.PageService;
            _searchService      = _container.SearchService;
            _configReaderWriter = new ConfigReaderWriterStub();
        }
Ejemplo n.º 6
0
        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;
            _searchService       = _container.SearchService;
            _markupConverter     = _container.MarkupConverter;

            _listCache          = _container.ListCache;
            _siteCache          = _container.SiteCache;
            _pageViewModelCache = _container.PageViewModelCache;
            _memoryCache        = _container.MemoryCache;

            _homeController = new HomeController(_applicationSettings, _userService, _markupConverter, _pageService, _searchService, _context, _settingsService);
            _homeController.SetFakeControllerContext();
        }
Ejemplo n.º 7
0
        /// <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");
            ConfigReaderWriter = new ConfigReaderWriterStub();

            // Cache
            MemoryCache        = useCacheMock ? new CacheMock() : CacheMock.RoadkillCache;
            ListCache          = new ListCache(ApplicationSettings, MemoryCache);
            SiteCache          = new SiteCache(MemoryCache);
            PageViewModelCache = new PageViewModelCache(ApplicationSettings, MemoryCache);

            // Repositories
            SettingsRepository = new SettingsRepositoryMock();
            SettingsRepository.SiteSettings            = new SiteSettings();
            SettingsRepository.SiteSettings.MarkupType = "Creole";
            UserRepository      = new UserRepositoryMock();
            PageRepository      = new PageRepositoryMock();
            InstallerRepository = new InstallerRepositoryMock();

            RepositoryFactory = new RepositoryFactoryMock()
            {
                SettingsRepository  = SettingsRepository,
                UserRepository      = UserRepository,
                PageRepository      = PageRepository,
                InstallerRepository = InstallerRepository
            };
            DatabaseTester = new DatabaseTesterMock();

            // Plugins
            PluginFactory   = new PluginFactoryMock();
            MarkupConverter = new MarkupConverter(ApplicationSettings, SettingsRepository, PageRepository, PluginFactory);

            // Services
            // Dependencies for PageService. Be careful to make sure the class using this Container isn't testing the mock.
            SettingsService            = new SettingsService(RepositoryFactory, ApplicationSettings);
            UserService                = new UserServiceMock(ApplicationSettings, UserRepository);
            UserContext                = new UserContext(UserService);
            SearchService              = new SearchServiceMock(ApplicationSettings, SettingsRepository, PageRepository, PluginFactory);
            SearchService.PageContents = PageRepository.PageContents;
            SearchService.Pages        = PageRepository.Pages;
            HistoryService             = new PageHistoryService(ApplicationSettings, SettingsRepository, PageRepository, UserContext,
                                                                PageViewModelCache, PluginFactory);
            FileService = new FileServiceMock();
            PageService = new PageService(ApplicationSettings, SettingsRepository, PageRepository, SearchService, HistoryService,
                                          UserContext, ListCache, PageViewModelCache, SiteCache, PluginFactory);

            StructureMapContainer = new Container(x =>
            {
                x.AddRegistry(new TestsRegistry(this));
            });

            Locator = new StructureMapServiceLocator(StructureMapContainer, false);

            InstallationService = new InstallationService((databaseName, connectionString) =>
            {
                InstallerRepository.DatabaseName     = databaseName;
                InstallerRepository.ConnectionString = connectionString;

                return(InstallerRepository);
            }, Locator);

            // EmailTemplates
            EmailClient = new EmailClientMock();
        }