HomePage enhancements

modules/cms-kit/src/Volo.CmsKit.Admin.Application/Volo/CmsKit/Admin/Pages/PageAdminAppService.cs

@@ -91,14 +91,9 @@ public class PageAdminAppService : CmsKitAdminAppServiceBase, IPageAdminAppServi
     public virtual async Task SetAsHomePageAsync(Guid id)
     {
         var page = await PageRepository.GetAsync(id);
-        if (!page.IsHomePage)
-        {
-            await PageManager.SetHomePageAsFalseAsync(true);
-            page = await PageRepository.GetAsync(id);
-        }
 
-        page.IsHomePage = !page.IsHomePage; ;
+		await PageManager.SetHomePageAsync(page);
 
-        await PageRepository.UpdateAsync(page);
+		await PageRepository.UpdateAsync(page);
     }
 }

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/CmsKitErrorCodes.cs

@@ -11,7 +11,8 @@ public static class CmsKitErrorCodes
     public static class Pages
     {
         public const string SlugAlreadyExist = "CmsKit:Page:0001";
-    }
+		public const string MultipleHomePage = "CmsKit:Page:0002";
+	}
 
     public static class Ratings
     {

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/Pages/IPageRepository.cs

@@ -23,5 +23,5 @@ public interface IPageRepository : IBasicRepository<Page, Guid>
 
     Task<bool> ExistsAsync(string slug, CancellationToken cancellationToken = default);
 
-    Task<Page> FindByIsHomePageAsync(bool isHomePage, CancellationToken cancellationToken = default);
+    Task<List<Page>> GetListOfHomePagesAsync(CancellationToken cancellationToken = default);
 }

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/Pages/MultipleHomePageException.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+using Volo.Abp;
+
+namespace Volo.CmsKit.Domain.Volo.CmsKit.Pages;
+
+[Serializable]
+public class MultipleHomePageException : BusinessException
+{
+	public MultipleHomePageException()
+	{
+		Code = CmsKitErrorCodes.Pages.MultipleHomePage;
+	}
+	
+	public MultipleHomePageException(SerializationInfo serializationInfo, StreamingContext context)
+		: base(serializationInfo, context)
+	{
+	}
+}

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/Pages/Page.cs

@@ -20,7 +20,7 @@ public class Page : FullAuditedAggregateRoot<Guid>, IMultiTenant
 
     public virtual string Style { get; protected set; }
 
-    public virtual bool IsHomePage { get; set; }
+    public virtual bool IsHomePage { get; protected set; }
 
     protected Page()
     {
@@ -68,4 +68,9 @@ public class Page : FullAuditedAggregateRoot<Guid>, IMultiTenant
     {
         Style = Check.Length(style, nameof(style), PageConsts.MaxStyleLength);
     }
+
+	internal void SetIsHomePage(bool isHomePage)
+    {
+        IsHomePage = isHomePage;
+	}
 }

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/Pages/PageManager.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Linq;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Volo.Abp;
 using Volo.Abp.Domain.Services;
@@ -7,59 +8,75 @@ namespace Volo.CmsKit.Pages;
 
 public class PageManager : DomainService
 {
-    protected IPageRepository PageRepository { get; }
+	protected IPageRepository PageRepository { get; }
 
-    public PageManager(IPageRepository pageRepository)
-    {
-        PageRepository = pageRepository;
-    }
+	public PageManager(IPageRepository pageRepository)
+	{
+		PageRepository = pageRepository;
+	}
 
-    public virtual async Task<Page> CreateAsync(
-        [NotNull] string title,
-        [NotNull] string slug,
-        [CanBeNull] string content = null,
-        [CanBeNull] string script = null,
-        [CanBeNull] string style = null)
-    {
-        Check.NotNullOrEmpty(title, nameof(title));
-        Check.NotNullOrEmpty(slug, nameof(slug));
+	public virtual async Task<Page> CreateAsync(
+		[NotNull] string title,
+		[NotNull] string slug,
+		[CanBeNull] string content = null,
+		[CanBeNull] string script = null,
+		[CanBeNull] string style = null)
+	{
+		Check.NotNullOrEmpty(title, nameof(title));
+		Check.NotNullOrEmpty(slug, nameof(slug));
 
-        await CheckPageSlugAsync(slug);
+		await CheckPageSlugAsync(slug);
 
-        return new Page(
-            GuidGenerator.Create(),
-            title,
-            slug,
-            content,
-            script,
-            style,
-            CurrentTenant.Id);
-    }
+		return new Page(
+			GuidGenerator.Create(),
+			title,
+			slug,
+			content,
+			script,
+			style,
+			CurrentTenant.Id);
+	}
 
-    public virtual async Task SetSlugAsync(Page page, string newSlug)
-    {
-        if (page.Slug != newSlug)
-        {
-            await CheckPageSlugAsync(newSlug);
-            page.SetSlug(newSlug);
-        }
-    }
+	public virtual async Task SetSlugAsync(Page page, string newSlug)
+	{
+		if (page.Slug != newSlug)
+		{
+			await CheckPageSlugAsync(newSlug);
+			page.SetSlug(newSlug);
+		}
+	}
 
-    public virtual async Task SetHomePageAsFalseAsync(bool isHomePage)
-    {
-        var page = await PageRepository.FindByIsHomePageAsync(isHomePage);
-        if (page is not null)
-        {
-            page.IsHomePage = false;
-            await PageRepository.UpdateAsync(page);
-        }
-    }
+	public virtual async Task SetHomePageAsync(Page page)
+	{
+		var currentHomePages = await PageRepository.GetListAsync();
 
-    protected virtual async Task CheckPageSlugAsync(string slug)
-    {
-        if (await PageRepository.ExistsAsync(slug))
-        {
-            throw new PageSlugAlreadyExistsException(slug);
-        }
-    }
+		foreach (var homePage in currentHomePages)
+		{
+			homePage.SetIsHomePage(false);
+		}
+
+		await PageRepository.UpdateManyAsync(currentHomePages);
+
+		page.SetIsHomePage(true);
+	}
+
+	public virtual async Task<Page> GetHomePageAsync()
+	{
+		var currentHomePages = await PageRepository.GetListAsync();
+
+		if (currentHomePages.Count > 1)
+		{
+			throw new BusinessException("There can be only one home page.");
+		}
+
+		return currentHomePages.FirstOrDefault();
+	}
+
+	protected virtual async Task CheckPageSlugAsync(string slug)
+	{
+		if (await PageRepository.ExistsAsync(slug))
+		{
+			throw new PageSlugAlreadyExistsException(slug);
+		}
+	}
 }

modules/cms-kit/src/Volo.CmsKit.EntityFrameworkCore/Volo/CmsKit/Pages/EfCorePageRepository.cs

@@ -64,8 +64,8 @@ public class EfCorePageRepository : EfCoreRepository<ICmsKitDbContext, Page, Gui
         return await (await GetDbSetAsync()).AnyAsync(x => x.Slug == slug, GetCancellationToken(cancellationToken));
     }
 
-    public virtual Task<Page> FindByIsHomePageAsync(bool isHomePage, CancellationToken cancellationToken = default)
+    public virtual Task<List<Page>> GetListOfHomePagesAsync(CancellationToken cancellationToken = default)
     {
-        return FindAsync(x => x.IsHomePage == isHomePage, cancellationToken: GetCancellationToken(cancellationToken));
+        return GetListAsync(x => x.IsHomePage, cancellationToken: GetCancellationToken(cancellationToken));
     }
 }

modules/cms-kit/src/Volo.CmsKit.MongoDB/Volo/CmsKit/MongoDB/Pages/MongoPageRepository.cs

@@ -72,8 +72,8 @@ public class MongoPageRepository : MongoDbRepository<ICmsKitMongoDbContext, Page
             GetCancellationToken(cancellationToken));
     }
 
-    public virtual Task<Page> FindByIsHomePageAsync(bool isHomePage, CancellationToken cancellationToken = default)
+    public virtual Task<List<Page>> GetListOfHomePagesAsync(CancellationToken cancellationToken = default)
     {
-        return FindAsync(x => x.IsHomePage == isHomePage, cancellationToken: GetCancellationToken(cancellationToken));
+        return GetListAsync(x => x.IsHomePage, cancellationToken: GetCancellationToken(cancellationToken));
     }
 }

modules/cms-kit/src/Volo.CmsKit.Public.Application/Volo/CmsKit/Public/Pages/PagePublicAppService.cs

@@ -16,14 +16,15 @@ namespace Volo.CmsKit.Public.Pages;
 public class PagePublicAppService : CmsKitPublicAppServiceBase, IPagePublicAppService
 {
     protected IPageRepository PageRepository { get; }
-    protected ContentParser ContentParser { get; }
-    private readonly IDistributedCache<PageDto> _cache;
+	protected PageManager PageManager { get; }
 
-    public PagePublicAppService(IPageRepository pageRepository, ContentParser contentParser, IDistributedCache<PageDto> cache)
+    protected IDistributedCache<PageDto> PageCache { get; }
+
+    public PagePublicAppService(IPageRepository pageRepository, PageManager pageManager, IDistributedCache<PageDto> pageCache)
     {
         PageRepository = pageRepository;
-        ContentParser = contentParser;
-        _cache = cache;
+        PageManager = pageManager;
+		PageCache = pageCache;
     }
 
     public virtual async Task<PageDto> FindBySlugAsync(string slug)
@@ -40,10 +41,10 @@ public class PagePublicAppService : CmsKitPublicAppServiceBase, IPagePublicAppSe
 
     public virtual async Task<PageDto> FindDefaultHomePageAsync()
     {
-        var pageDto = await _cache.GetAsync("DefaultHomePage");
+        var pageDto = await PageCache.GetAsync("DefaultHomePage");
         if (pageDto is null)
         {
-            var page = await PageRepository.FindByIsHomePageAsync(true);
+            var page = await PageManager.GetHomePageAsync();
             if (page is null)
             {
                 return null;
@@ -51,7 +52,7 @@ public class PagePublicAppService : CmsKitPublicAppServiceBase, IPagePublicAppSe
 
             pageDto = ObjectMapper.Map<Page, PageDto>(page);
 
-            await _cache.SetAsync("DefaultHomePage", pageDto,
+            await PageCache.SetAsync("DefaultHomePage", pageDto,
                 new DistributedCacheEntryOptions { AbsoluteExpiration = DateTimeOffset.Now.AddHours(1) });
         }
 

modules/cms-kit/test/Volo.CmsKit.Domain.Tests/Pages/PageManager_Test.cs

@@ -1,97 +1,111 @@
 using System.Threading.Tasks;
 using Shouldly;
+using Volo.CmsKit.Tags;
 using Xunit;
 
 namespace Volo.CmsKit.Pages;
 
 public class PageManager_Test : CmsKitDomainTestBase
 {
-    private readonly PageManager pageManager;
-    private readonly CmsKitTestData testData;
-    private readonly IPageRepository pageRepository;
-
-    public PageManager_Test()
-    {
-        pageManager = GetRequiredService<PageManager>();
-        testData = GetRequiredService<CmsKitTestData>();
-        pageRepository = GetRequiredService<IPageRepository>();
-    }
-
-    [Fact]
-    public async Task CreateAsync_ShouldWorkProperly_WithNonExistingSlug()
-    {
-        var title = "My awesome page";
-        var slug = "my-awesome-page";
-        var content = "<h1>My Awesome Page</h1><p>This is my awesome page content!</p>";
-
-        var page = await pageManager.CreateAsync(title, slug, content);
-
-        page.ShouldNotBeNull();
-        page.Title.ShouldBe(title);
-        page.Slug.ShouldBe(slug);
-        page.Content.ShouldBe(content);
-    }
-
-    [Fact]
-    public async Task CreateAsync_ShouldThrowException_WithExistingSlug()
-    {
-        var title = "My awesome page";
-        var slug = testData.Page_1_Slug;
-        var content = "<h1>My Awesome Page</h1><p>This is my awesome page content!</p>";
-
-        var exception = await Should.ThrowAsync<PageSlugAlreadyExistsException>(async () =>
-                            await pageManager.CreateAsync(title, slug, content));
-
-        exception.ShouldNotBeNull();
-    }
-
-    [Fact]
-    public async Task SetSlugAsync_ShouldWorkProperly_WithNonExistingSlug()
-    {
-        var newSlug = "freshly-generated-new-slug";
-        var page = await pageRepository.GetAsync(testData.Page_1_Id);
-
-        await pageManager.SetSlugAsync(page, newSlug);
-
-        page.Slug.ShouldBe(newSlug);
-    }
-
-    [Fact]
-    public async Task SetSlugAsync_ShouldThrowException_WithExistingSlug()
-    {
-        var newSlug = testData.Page_2_Slug;
-        var page = await pageRepository.GetAsync(testData.Page_1_Id);
-
-        var exception = await Should.ThrowAsync<PageSlugAlreadyExistsException>(async () =>
-                            await pageManager.SetSlugAsync(page, newSlug));
-
-        exception.ShouldNotBeNull();
-    }
-
-    [Fact]
-    public async Task SetHomePageAsFalseAsync_ShouldWorkProperly_IfExistHomePage()
-    {
-        var page = await pageRepository.GetAsync(testData.Page_1_Id);
-        page.IsHomePage = true;
-        await pageRepository.UpdateAsync(page);
-        
-        await pageManager.SetHomePageAsFalseAsync(true);
-        
-        page.IsHomePage.ShouldBeTrue();
-        
-        var pageSetAsHomePageAsFalse = await pageRepository.GetAsync(testData.Page_2_Id);
-        pageSetAsHomePageAsFalse.IsHomePage.ShouldBeFalse();
-    }
-
-    [Fact]
-    public async Task SetHomePageAsFalseAsync_ShouldWorkProperly_IfNotExistHomePage()
-    {
-        var page = await pageRepository.GetAsync(testData.Page_1_Id);
-        page.IsHomePage = true;
-        await pageManager.SetHomePageAsFalseAsync(true);
-        page.IsHomePage.ShouldBeTrue();
-
-        var pageSetAsHomePageAsFalse = await pageRepository.GetAsync(testData.Page_2_Id);
-        pageSetAsHomePageAsFalse.IsHomePage.ShouldBeFalse();
-    }
+	private readonly PageManager pageManager;
+	private readonly CmsKitTestData testData;
+	private readonly IPageRepository pageRepository;
+
+	public PageManager_Test()
+	{
+		pageManager = GetRequiredService<PageManager>();
+		testData = GetRequiredService<CmsKitTestData>();
+		pageRepository = GetRequiredService<IPageRepository>();
+	}
+
+	[Fact]
+	public async Task CreateAsync_ShouldWorkProperly_WithNonExistingSlug()
+	{
+		var title = "My awesome page";
+		var slug = "my-awesome-page";
+		var content = "<h1>My Awesome Page</h1><p>This is my awesome page content!</p>";
+
+		var page = await pageManager.CreateAsync(title, slug, content);
+
+		page.ShouldNotBeNull();
+		page.Title.ShouldBe(title);
+		page.Slug.ShouldBe(slug);
+		page.Content.ShouldBe(content);
+	}
+
+	[Fact]
+	public async Task CreateAsync_ShouldThrowException_WithExistingSlug()
+	{
+		var title = "My awesome page";
+		var slug = testData.Page_1_Slug;
+		var content = "<h1>My Awesome Page</h1><p>This is my awesome page content!</p>";
+
+		var exception = await Should.ThrowAsync<PageSlugAlreadyExistsException>(async () =>
+							await pageManager.CreateAsync(title, slug, content));
+
+		exception.ShouldNotBeNull();
+	}
+
+	[Fact]
+	public async Task SetSlugAsync_ShouldWorkProperly_WithNonExistingSlug()
+	{
+		var newSlug = "freshly-generated-new-slug";
+		var page = await pageRepository.GetAsync(testData.Page_1_Id);
+
+		await pageManager.SetSlugAsync(page, newSlug);
+
+		page.Slug.ShouldBe(newSlug);
+	}
+
+	[Fact]
+	public async Task SetSlugAsync_ShouldThrowException_WithExistingSlug()
+	{
+		var newSlug = testData.Page_2_Slug;
+		var page = await pageRepository.GetAsync(testData.Page_1_Id);
+
+		var exception = await Should.ThrowAsync<PageSlugAlreadyExistsException>(async () =>
+							await pageManager.SetSlugAsync(page, newSlug));
+
+		exception.ShouldNotBeNull();
+	}
+
+	[Fact]
+	public async Task SetHomePageAsync_ShouldWorkProperly_IfExistHomePage()
+	{
+		var page = await pageRepository.GetAsync(testData.Page_1_Id);
+
+		await pageManager.SetHomePageAsync(page);
+
+		await pageRepository.UpdateAsync(page);
+
+		page.IsHomePage.ShouldBeTrue();
+
+		var pageSetAsHomePageAsFalse = await pageRepository.GetAsync(testData.Page_2_Id);
+		pageSetAsHomePageAsFalse.IsHomePage.ShouldBeFalse();
+	}
+
+	[Fact]
+	public async Task SetHomePageAsync_ShouldFix_WhenMultipleHomePageExist()
+	{
+		await WithUnitOfWorkAsync(async () =>
+		{
+			var page1 = await pageRepository.GetAsync(testData.Page_1_Id);
+			var page2 = await pageRepository.GetAsync(testData.Page_2_Id);
+
+			page1.SetIsHomePage(true);
+			page2.SetIsHomePage(true);
+
+			await pageRepository.UpdateManyAsync(new[] { page1, page2 }, autoSave: true);
+
+			await pageManager.SetHomePageAsync(page1);
+		});
+
+		var page1 = await pageRepository.GetAsync(testData.Page_1_Id);
+		var page2 = await pageRepository.GetAsync(testData.Page_2_Id);
+
+		page2 = await pageRepository.GetAsync(testData.Page_2_Id);
+
+		page1.IsHomePage.ShouldBeTrue();
+		page2.IsHomePage.ShouldBeFalse();
+	}
 }

modules/cms-kit/test/Volo.CmsKit.TestBase/Pages/PageRepository_Test.cs

@@ -7,96 +7,96 @@ using Xunit;
 namespace Volo.CmsKit.Pages;
 
 public abstract class PageRepository_Test<TStartupModule> : CmsKitTestBase<TStartupModule>
-    where TStartupModule : IAbpModule
+	where TStartupModule : IAbpModule
 {
-    private readonly CmsKitTestData _cmsKitTestData;
-    private readonly IPageRepository _pageRepository;
-
-    protected PageRepository_Test()
-    {
-        _cmsKitTestData = GetRequiredService<CmsKitTestData>();
-        _pageRepository = GetRequiredService<IPageRepository>();
-    }
-
-    [Fact]
-    public async Task CountAsync()
-    {
-        var totalCount = await _pageRepository.GetCountAsync();
-
-        totalCount.ShouldBe(2);
-
-        var filteredCount = await _pageRepository.GetCountAsync(_cmsKitTestData.Page_2_Title);
-
-        filteredCount.ShouldBe(1);
-    }
-
-    [Fact]
-    public async Task GetListAsync()
-    {
-        var list = await _pageRepository.GetListAsync();
-
-        list.ShouldNotBeNull();
-        list.Count.ShouldBe(2);
-
-        var list_page_1 = await _pageRepository.GetListAsync(maxResultCount: 1);
-        var list_page_2 = await _pageRepository.GetListAsync(maxResultCount: 1, skipCount: 1);
-
-        list_page_1.ShouldNotBeNull();
-        list_page_1.Count.ShouldBe(1);
-        list_page_1.First().Title.ShouldBe(_cmsKitTestData.Page_1_Title);
-
-        list_page_2.ShouldNotBeNull();
-        list_page_1.Count.ShouldBe(1);
-        list_page_2.First().Title.ShouldBe(_cmsKitTestData.Page_2_Title);
-    }
-
-    [Fact]
-    public async Task ShouldGetByUrlAsync()
-    {
-        var page = await _pageRepository.GetBySlugAsync(_cmsKitTestData.Page_1_Slug);
-
-        page.ShouldNotBeNull();
-        page.Title.ShouldBe(_cmsKitTestData.Page_1_Title);
-    }
-
-    [Fact]
-    public async Task ShouldFindByUrlAsync()
-    {
-        var page = await _pageRepository.FindBySlugAsync(_cmsKitTestData.Page_1_Slug);
-
-        page.ShouldNotBeNull();
-        page.Title.ShouldBe(_cmsKitTestData.Page_1_Title);
-    }
-
-    [Fact]
-    public async Task ShouldNotFindByUrlAsync()
-    {
-        var page = await _pageRepository.FindBySlugAsync("not-exist-lyrics");
-
-        page.ShouldBeNull();
-    }
-
-    [Fact]
-    public async Task ShouldBeExistAsync()
-    {
-        var page = await _pageRepository.ExistsAsync(_cmsKitTestData.Page_1_Slug);
-
-        page.ShouldBeTrue();
-    }
-
-    [Fact]
-    public async Task ShouldNotBeExistAsync()
-    {
-        var page = await _pageRepository.ExistsAsync("not-exist-lyrics");
-
-        page.ShouldBeFalse();
-    }
-
-    [Fact]
-    public async Task ShouldNotBeFindByIsHomePageAsync()
-    {
-        var page = await _pageRepository.FindByIsHomePageAsync(true);
-        
-        page.ShouldBeNull();
-    }
+	private readonly CmsKitTestData _cmsKitTestData;
+	private readonly IPageRepository _pageRepository;
+
+	protected PageRepository_Test()
+	{
+		_cmsKitTestData = GetRequiredService<CmsKitTestData>();
+		_pageRepository = GetRequiredService<IPageRepository>();
+	}
+
+	[Fact]
+	public async Task CountAsync()
+	{
+		var totalCount = await _pageRepository.GetCountAsync();
+
+		totalCount.ShouldBe(2);
+
+		var filteredCount = await _pageRepository.GetCountAsync(_cmsKitTestData.Page_2_Title);
+
+		filteredCount.ShouldBe(1);
+	}
+
+	[Fact]
+	public async Task GetListAsync()
+	{
+		var list = await _pageRepository.GetListAsync();
+
+		list.ShouldNotBeNull();
+		list.Count.ShouldBe(2);
+
+		var list_page_1 = await _pageRepository.GetListAsync(maxResultCount: 1);
+		var list_page_2 = await _pageRepository.GetListAsync(maxResultCount: 1, skipCount: 1);
+
+		list_page_1.ShouldNotBeNull();
+		list_page_1.Count.ShouldBe(1);
+		list_page_1.First().Title.ShouldBe(_cmsKitTestData.Page_1_Title);
+
+		list_page_2.ShouldNotBeNull();
+		list_page_1.Count.ShouldBe(1);
+		list_page_2.First().Title.ShouldBe(_cmsKitTestData.Page_2_Title);
+	}
+
+	[Fact]
+	public async Task ShouldGetByUrlAsync()
+	{
+		var page = await _pageRepository.GetBySlugAsync(_cmsKitTestData.Page_1_Slug);
+
+		page.ShouldNotBeNull();
+		page.Title.ShouldBe(_cmsKitTestData.Page_1_Title);
+	}
+
+	[Fact]
+	public async Task ShouldFindByUrlAsync()
+	{
+		var page = await _pageRepository.FindBySlugAsync(_cmsKitTestData.Page_1_Slug);
+
+		page.ShouldNotBeNull();
+		page.Title.ShouldBe(_cmsKitTestData.Page_1_Title);
+	}
+
+	[Fact]
+	public async Task ShouldNotFindByUrlAsync()
+	{
+		var page = await _pageRepository.FindBySlugAsync("not-exist-lyrics");
+
+		page.ShouldBeNull();
+	}
+
+	[Fact]
+	public async Task ShouldBeExistAsync()
+	{
+		var page = await _pageRepository.ExistsAsync(_cmsKitTestData.Page_1_Slug);
+
+		page.ShouldBeTrue();
+	}
+
+	[Fact]
+	public async Task ShouldNotBeExistAsync()
+	{
+		var page = await _pageRepository.ExistsAsync("not-exist-lyrics");
+
+		page.ShouldBeFalse();
+	}
+
+	[Fact]
+	public async Task ShouldntFindByIsHomePageAsync()
+	{
+		var pages = await _pageRepository.GetListOfHomePagesAsync();
+
+		pages.ShouldBeEmpty();
+	}
 }