public void FindShould_ReturnCorrectValue()
        {
            // Arrange
            int  bookCatNum = 1;
            Guid bookId     = Guid.NewGuid();
            Book book       = new Book()
            {
                Id = bookId, CatalogueNumber = bookCatNum
            };
            int  pageNum1 = 1;
            int  pageNum2 = 2;
            Page page1    = new Page()
            {
                Book = book, Number = pageNum1
            };
            Page page2 = new Page()
            {
                Book = book, Number = pageNum2
            };
            var list = new List <Page>()
            {
                page1, page2
            };
            var pagesService = new PagesService(pageRepoMock.Object, bookServiceMock.Object, contextMock.Object);

            // Act
            bookServiceMock.Setup(x => x.FindSingle(bookCatNum)).Returns(book);
            pageRepoMock.Setup(x => x.All).Returns(list.AsQueryable);
            var result = pagesService.Find(bookCatNum, pageNum2);

            // Assert
            Assert.AreEqual(page2, result);
        }
        public async Task AddPagesAsyncThrowsArgumentExceptionWhenGivenAnInvalidFileSize()
        {
            var pages         = new List <Page>();
            var mockPagesRepo = new Mock <IPagesRepository>();
            var mockIFormFile = new Mock <IFormFile>();
            var content       = "Fake content";
            var fileName      = "test.jpeg";
            var contentType   = ".jpeg";
            var ms            = new MemoryStream();
            var writer        = new StreamWriter(ms);

            writer.Write(content);
            writer.Flush();
            ms.Position = 0;
            mockIFormFile.Setup(x => x.OpenReadStream()).Returns(ms);
            mockIFormFile.Setup(x => x.ContentType).Returns(contentType);
            mockIFormFile.Setup(x => x.FileName).Returns(fileName);
            mockIFormFile.Setup(x => x.Length).Returns(ms.Length * 1024 * 1024 * 1024);
            var formFilePages = new List <IFormFile>();

            formFilePages.Add(mockIFormFile.Object);
            var service = new PagesService(mockPagesRepo.Object);

            await Assert.ThrowsAsync <ArgumentException>(() => service.AddPagesAsync(formFilePages, "hello", "sadness"));
        }
        public void SetUp()
        {
            var options = new DbContextOptionsBuilder <ApplicationDbContext>()
                          .UseInMemoryDatabase(Guid.NewGuid().ToString());

            this.repository = new EfDeletableEntityRepository <Page>(new ApplicationDbContext(options.Options));
            this.service    = new PagesService(this.repository);
            AutoMapperConfig.RegisterMappings(typeof(TestPage).Assembly);
        }
        public void FindShould_ReturnCorrectType()
        {
            // Arrang
            var list         = new List <Page>();
            var pagesService = new PagesService(pageRepoMock.Object, bookServiceMock.Object, contextMock.Object);

            // Act
            pageRepoMock.Setup(x => x.All).Returns(list.AsQueryable);
            var result = pagesService.Find(1, 1);

            // Assert
            Assert.IsInstanceOf(typeof(Page), result);
        }
        public void UpdateShould_ReturnValue()
        {
            // Arrange
            var  pagesService = new PagesService(pageRepoMock.Object, bookServiceMock.Object, contextMock.Object);
            Page page         = new Page();

            // Arrange
            contextMock.Setup(x => x.Commit()).Returns(1);
            var result = pagesService.Update(page);

            // Assert
            Assert.IsInstanceOf(typeof(int), result);
        }
Esempio n. 6
0
        public override object BeforeMethod(string method)
        {
            var result = this.Root.SingleOrDefault(x => x.Handle == method);

            if (result == null)
            {
                var context  = SiteContext.Current;
                var response = new PagesService().GetPage(context, method);
                return(response);
            }

            return(result);
        }
Esempio n. 7
0
 public PagesController(
     PagesService ps,
     NewsService newsService,
     FileService fs,
     IHostingEnvironment environment,
     AdService adService,
     ExecutionService es,
     AccountService accountService
     )
 {
     this.ps             = ps;
     this.newsService    = newsService;
     this.fs             = fs;
     this.environment    = environment;
     this.adService      = adService;
     this.es             = es;
     this.accountService = accountService;
 }
Esempio n. 8
0
 public AccountService(
     EncryptionService encryptionService,
     IOptions <LinksOptions> op,
     LinksContext db,
     ExecutionService es,
     FileService fs,
     PagesService ps,
     IHttpContextAccessor httpContext,
     MailService mas
     )
 {
     this.encryptionService = encryptionService;
     this.op          = op;
     this.db          = db;
     this.es          = es;
     this.fs          = fs;
     this.ps          = ps;
     this.mas         = mas;
     this.httpContext = httpContext;
 }
Esempio n. 9
0
        public PagesServiceTests()
        {
            AutoMapperConfig.RegisterMappings(Assembly.Load("HiWorld.Services.Data.Tests"));

            var mockImageService = new Mock <IImagesService>();

            mockImageService.Setup(x => x.CreateAsync(It.IsAny <IFormFile>(), It.IsAny <string>()))
            .Returns(Task.Run(() => "test"));
            this.imagesService = mockImageService.Object;

            var mockTagService = new Mock <ITagsService>();

            mockTagService.Setup(x => x.GetIdAsync(It.IsAny <string>()))
            .Returns(Task.Run(() => 2));
            this.tagsService = mockTagService.Object;

            var mockPostService = new Mock <IPostsService>();

            mockPostService.Setup(x => x.DeleteAllPostsFromPageAsync(It.IsAny <int>()))
            .Returns(Task.Run(() => { return; }));
            this.postsService = mockPostService.Object;

            var connection = new DbContextOptionsBuilder <ApplicationDbContext>()
                             .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString());

            this.dbContext = new ApplicationDbContext(connection.Options);
            this.dbContext.Database.EnsureCreated();

            this.pagesRepository     = new EfDeletableEntityRepository <Page>(this.dbContext);
            this.followersRepository = new EfRepository <PageFollower>(this.dbContext);
            this.pageTagsRepository  = new EfRepository <PageTag>(this.dbContext);
            this.pagesService        = new PagesService(
                this.pagesRepository,
                this.followersRepository,
                this.pageTagsRepository,
                this.tagsService,
                this.imagesService,
                this.postsService);
        }
        public async Task AddPagesAsyncWorksCorrectlyWithPng()
        {
            var pages         = new List <Page>();
            var mockPagesRepo = new Mock <IPagesRepository>();
            var mockIFormFile = new Mock <IFormFile>();
            var content       = "Fake content";
            var fileName      = "test.png";
            var contentType   = ".png";
            var ms            = new MemoryStream();
            var writer        = new StreamWriter(ms);

            writer.Write(content);
            writer.Flush();
            ms.Position = 0;
            mockIFormFile.Setup(x => x.OpenReadStream()).Returns(ms);
            mockIFormFile.Setup(x => x.ContentType).Returns(contentType);
            mockIFormFile.Setup(x => x.FileName).Returns(fileName);
            mockIFormFile.Setup(x => x.Length).Returns(ms.Length);
            mockPagesRepo.Setup(x => x.AddAsync(It.IsAny <Page>())).Callback((Page page) => pages.Add(page));
            var formFilePages = new List <IFormFile>();

            formFilePages.Add(mockIFormFile.Object);
            var service = new PagesService(mockPagesRepo.Object);

            // Had to make a specific folder for this to go through
            var result = await service.AddPagesAsync(formFilePages, @"C:\Users\Smashcake\Desktop\forUnitTest", "test");

            Assert.Single(pages);
            Assert.Single(result);
            Assert.Equal("test", pages.First().EpisodeId);
            Assert.Equal("test", result.First().EpisodeId);
            Assert.Equal(1, pages.First().PageNumber);
            Assert.Equal(1, result.First().PageNumber);
            Assert.Equal("png", pages.First().FileExtention);
            Assert.Equal("png", result.First().FileExtention);
            Assert.Equal("/page1.png", pages.First().FilePath);
            Assert.Equal("/page1.png", result.First().FilePath);
        }
        public async Task AddPagesAsyncWorksCorrectlyWithJpeg()
        {
            var pages         = new List <Page>();
            var mockPagesRepo = new Mock <IPagesRepository>();
            var mockIFormFile = new Mock <IFormFile>();
            var content       = "Fake content";
            var fileName      = "test.jpeg";
            var contentType   = ".jpeg";
            var ms            = new MemoryStream();
            var writer        = new StreamWriter(ms);

            writer.Write(content);
            writer.Flush();
            ms.Position = 0;
            mockIFormFile.Setup(x => x.OpenReadStream()).Returns(ms);
            mockIFormFile.Setup(x => x.ContentType).Returns(contentType);
            mockIFormFile.Setup(x => x.FileName).Returns(fileName);
            mockIFormFile.Setup(x => x.Length).Returns(ms.Length);
            mockPagesRepo.Setup(x => x.AddAsync(It.IsAny <Page>())).Callback((Page page) => pages.Add(page));
            var formFilePages = new List <IFormFile>();

            formFilePages.Add(mockIFormFile.Object);
            var service = new PagesService(mockPagesRepo.Object);

            var result = await service.AddPagesAsync(formFilePages, @"C:\MyWebtoonWebProject\MyWebtoonWebProject\TestResults", "test");

            Assert.Single(pages);
            Assert.Single(result);
            Assert.Equal("test", pages.First().EpisodeId);
            Assert.Equal("test", result.First().EpisodeId);
            Assert.Equal(1, pages.First().PageNumber);
            Assert.Equal(1, result.First().PageNumber);
            Assert.Equal("jpeg", pages.First().FileExtention);
            Assert.Equal("jpeg", result.First().FileExtention);
            Assert.Equal("/page1.jpeg", pages.First().FilePath);
            Assert.Equal("/page1.jpeg", result.First().FilePath);
        }
        protected override bool IsMatch(
            HttpContextBase httpContext,
            Route route,
            string parameterName,
            RouteValueDictionary values,
            RouteDirection routeDirection)
        {
            if (!base.IsMatch(httpContext, route, parameterName, values, routeDirection))
            {
                return(false);
            }

            if (routeDirection == RouteDirection.UrlGeneration)
            {
                return(true);
            }

            var pagePath = values[parameterName].ToString();

            var context = SiteContext.Current;
            var model   = new PagesService().GetPage(context, pagePath);

            return(model != null);
        }
Esempio n. 13
0
        public BlogCollection GetBlogs(SiteContext context)
        {
            var service = new PagesService();

            return(new BlogCollection(service.GetBlogs(context)));
        }
Esempio n. 14
0
 public SiteMapBuilder(PagesService pagesService)
 {
     _pagesService = pagesService;
 }
Esempio n. 15
0
 public PagesController(PagesService service) : base(service)
 {
     _service = service;
 }
Esempio n. 16
0
 public ContentController(PagesService pagesService, CategoriesService categoriesService, SeoService seoService)
 {
     _pagesService      = pagesService;
     _categoriesService = categoriesService;
     _seoService        = seoService;
 }
Esempio n. 17
0
 public AttachmentUI.Mixin Attachment(int pageId)
 {
     return(Attachments.AsMixin(PagesService.AttachmentDomain(pageId)));
 }