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);
}
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);
}
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;
}
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;
}
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);
}
public BlogCollection GetBlogs(SiteContext context)
{
var service = new PagesService();
return(new BlogCollection(service.GetBlogs(context)));
}
public SiteMapBuilder(PagesService pagesService)
{
_pagesService = pagesService;
}
public PagesController(PagesService service) : base(service)
{
_service = service;
}
public ContentController(PagesService pagesService, CategoriesService categoriesService, SeoService seoService)
{
_pagesService = pagesService;
_categoriesService = categoriesService;
_seoService = seoService;
}
public AttachmentUI.Mixin Attachment(int pageId)
{
return(Attachments.AsMixin(PagesService.AttachmentDomain(pageId)));
}
