From e711706479a00adc70704a4ab14f5c9950d08334 Mon Sep 17 00:00:00 2001
From: Kamyab7 <valipourkamyab.official@gmail.com>
Date: Sun, 11 Feb 2024 19:25:08 +0330
Subject: [PATCH 1/2] async naming conventions added to .editorconfig

---
 .editorconfig | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/.editorconfig b/.editorconfig
index 459d75213..05199aa36 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -75,6 +75,20 @@ dotnet_naming_symbols.instance_fields.applicable_kinds = field
 
 dotnet_naming_style.instance_field_style.capitalization = camel_case
 dotnet_naming_style.instance_field_style.required_prefix = _
+
+# Async naming conventions
+dotnet_naming_rule.suffix_async_should_be_asyncsuffix.severity = error #suggestion
+dotnet_naming_rule.suffix_async_should_be_asyncsuffix.symbols = suffix_async
+dotnet_naming_rule.suffix_async_should_be_asyncsuffix.style = asyncsuffix
+
+dotnet_naming_symbols.suffix_async.applicable_kinds = method
+dotnet_naming_symbols.suffix_async.applicable_accessibilities = *
+dotnet_naming_symbols.suffix_async.required_modifiers = async
+
+dotnet_naming_style.asyncsuffix.required_prefix = 
+dotnet_naming_style.asyncsuffix.required_suffix = Async
+dotnet_naming_style.asyncsuffix.word_separator = 
+dotnet_naming_style.asyncsuffix.capitalization = pascal_case
 ###############################
 # C# Coding Conventions       #
 ###############################

From 681e6073eee4e4c18d5ab2ab35c482a2605afff3 Mon Sep 17 00:00:00 2001
From: Kamyab7 <valipourkamyab.official@gmail.com>
Date: Sun, 11 Feb 2024 20:27:42 +0330
Subject: [PATCH 2/2] inconsistent naming of async methods fixed

---
 .../Interfaces/IBasketQueryService.cs         |  2 +-
 .../Interfaces/IBasketService.cs              |  4 +-
 src/ApplicationCore/Services/BasketService.cs |  4 +-
 src/BlazorAdmin/CustomAuthStateProvider.cs    |  8 +--
 src/BlazorAdmin/JavaScript/Cookies.cs         |  4 +-
 src/BlazorAdmin/JavaScript/Css.cs             |  4 +-
 src/BlazorAdmin/JavaScript/Route.cs           |  2 +-
 .../Pages/CatalogItemPage/Create.razor        | 20 +++---
 .../Pages/CatalogItemPage/Delete.razor        | 22 +++---
 .../Pages/CatalogItemPage/Details.razor       | 20 +++---
 .../Pages/CatalogItemPage/Edit.razor          | 22 +++---
 .../Pages/CatalogItemPage/List.razor          | 16 ++---
 .../Pages/CatalogItemPage/List.razor.cs       | 26 +++----
 src/BlazorAdmin/Pages/Logout.razor            |  2 +-
 src/BlazorAdmin/Program.cs                    |  4 +-
 .../CachedCatalogItemServiceDecorator.cs      | 34 +++++-----
 ...achedCatalogLookupDataServiceDecorator .cs |  4 +-
 .../Services/CatalogItemService.cs            | 36 +++++-----
 .../Services/CatalogLookupDataService.cs      |  2 +-
 src/BlazorAdmin/Services/HttpService.cs       | 18 ++---
 src/BlazorAdmin/Shared/MainLayout.razor       |  2 +-
 .../Interfaces/ICatalogItemService.cs         | 12 ++--
 .../Interfaces/ICatalogLookupDataService.cs   |  2 +-
 src/BlazorShared/Models/CatalogItem.cs        |  2 +-
 .../Data/Queries/BasketQueryService.cs        |  2 +-
 .../Identity/Pages/Account/Logout.cshtml.cs   |  2 +-
 src/Web/Controllers/ManageController.cs       | 68 +++++++++----------
 src/Web/Controllers/OrderController.cs        |  4 +-
 src/Web/Controllers/UserController.cs         |  8 +--
 src/Web/Interfaces/IBasketViewModelService.cs |  6 +-
 .../ICatalogItemViewModelService.cs           |  2 +-
 .../Interfaces/ICatalogViewModelService.cs    |  6 +-
 src/Web/Pages/Admin/EditCatalogItem.cshtml.cs |  2 +-
 src/Web/Pages/Basket/Checkout.cshtml.cs       | 10 +--
 src/Web/Pages/Basket/Index.cshtml.cs          | 18 ++---
 src/Web/Pages/Index.cshtml.cs                 |  4 +-
 .../Components/BasketComponent/Basket.cs      |  8 +--
 src/Web/Services/BasketViewModelService.cs    | 18 ++---
 .../Services/CachedCatalogViewModelService.cs | 12 ++--
 .../Services/CatalogItemViewModelService.cs   |  2 +-
 src/Web/Services/CatalogViewModelService.cs   | 10 +--
 .../Controllers/AccountControllerSignIn.cs    |  8 +--
 .../Web/Controllers/CatalogControllerIndex.cs |  2 +-
 .../Web/Controllers/OrderControllerIndex.cs   |  2 +-
 .../Web/Pages/Basket/BasketPageCheckout.cs    |  2 +-
 .../Web/Pages/Basket/CheckoutTest.cs          |  2 +-
 .../Web/Pages/Basket/IndexTest.cs             |  4 +-
 .../Web/Pages/HomePageOnGet.cs                |  2 +-
 .../BasketRepositoryTests/SetQuantities.cs    |  4 +-
 .../OrderRepositoryTests/GetById.cs           |  2 +-
 .../GetByIdWithItemsAsync.cs                  |  2 +-
 .../AuthEndpoints/AuthenticateEndpointTest.cs |  2 +-
 .../CatalogItemGetByIdEndpointTest.cs         |  4 +-
 .../CatalogItemListPagedEndpoint.cs           |  6 +-
 .../CreateCatalogItemEndpointTest.cs          |  4 +-
 .../DeleteCatalogItemEndpointTest.cs          |  4 +-
 .../BasketServiceTests/AddItemToBasket.cs     |  8 +--
 .../BasketServiceTests/DeleteBasket.cs        |  2 +-
 .../BasketServiceTests/TransferBasket.cs      |  8 +--
 .../OrdersTests/GetMyOrders.cs                |  2 +-
 .../OrdersTests/GetOrderDetails.cs            |  2 +-
 61 files changed, 263 insertions(+), 263 deletions(-)

diff --git a/src/ApplicationCore/Interfaces/IBasketQueryService.cs b/src/ApplicationCore/Interfaces/IBasketQueryService.cs
index 6136df765..5fefa409c 100644
--- a/src/ApplicationCore/Interfaces/IBasketQueryService.cs
+++ b/src/ApplicationCore/Interfaces/IBasketQueryService.cs
@@ -7,6 +7,6 @@ namespace Microsoft.eShopWeb.ApplicationCore.Interfaces;
 /// </summary>
 public interface IBasketQueryService
 {
-    Task<int> CountTotalBasketItems(string username);
+    Task<int> CountTotalBasketItemsAsync(string username);
 }
 
diff --git a/src/ApplicationCore/Interfaces/IBasketService.cs b/src/ApplicationCore/Interfaces/IBasketService.cs
index 204f5f142..6435e24ce 100644
--- a/src/ApplicationCore/Interfaces/IBasketService.cs
+++ b/src/ApplicationCore/Interfaces/IBasketService.cs
@@ -8,7 +8,7 @@ namespace Microsoft.eShopWeb.ApplicationCore.Interfaces;
 public interface IBasketService
 {
     Task TransferBasketAsync(string anonymousId, string userName);
-    Task<Basket> AddItemToBasket(string username, int catalogItemId, decimal price, int quantity = 1);
-    Task<Result<Basket>> SetQuantities(int basketId, Dictionary<string, int> quantities);
+    Task<Basket> AddItemToBasketAsync(string username, int catalogItemId, decimal price, int quantity = 1);
+    Task<Result<Basket>> SetQuantitiesAsync(int basketId, Dictionary<string, int> quantities);
     Task DeleteBasketAsync(int basketId);
 }
diff --git a/src/ApplicationCore/Services/BasketService.cs b/src/ApplicationCore/Services/BasketService.cs
index ec810f397..4558d4efd 100644
--- a/src/ApplicationCore/Services/BasketService.cs
+++ b/src/ApplicationCore/Services/BasketService.cs
@@ -20,7 +20,7 @@ public BasketService(IRepository<Basket> basketRepository,
         _logger = logger;
     }
 
-    public async Task<Basket> AddItemToBasket(string username, int catalogItemId, decimal price, int quantity = 1)
+    public async Task<Basket> AddItemToBasketAsync(string username, int catalogItemId, decimal price, int quantity = 1)
     {
         var basketSpec = new BasketWithItemsSpecification(username);
         var basket = await _basketRepository.FirstOrDefaultAsync(basketSpec);
@@ -44,7 +44,7 @@ public async Task DeleteBasketAsync(int basketId)
         await _basketRepository.DeleteAsync(basket);
     }
 
-    public async Task<Result<Basket>> SetQuantities(int basketId, Dictionary<string, int> quantities)
+    public async Task<Result<Basket>> SetQuantitiesAsync(int basketId, Dictionary<string, int> quantities)
     {
         var basketSpec = new BasketWithItemsSpecification(basketId);
         var basket = await _basketRepository.FirstOrDefaultAsync(basketSpec);
diff --git a/src/BlazorAdmin/CustomAuthStateProvider.cs b/src/BlazorAdmin/CustomAuthStateProvider.cs
index 30cf42cb2..d06e58ab4 100644
--- a/src/BlazorAdmin/CustomAuthStateProvider.cs
+++ b/src/BlazorAdmin/CustomAuthStateProvider.cs
@@ -30,10 +30,10 @@ public CustomAuthStateProvider(HttpClient httpClient,
 
     public override async Task<AuthenticationState> GetAuthenticationStateAsync()
     {
-        return new AuthenticationState(await GetUser(useCache: true));
+        return new AuthenticationState(await GetUserAsync(useCache: true));
     }
 
-    private async ValueTask<ClaimsPrincipal> GetUser(bool useCache = false)
+    private async ValueTask<ClaimsPrincipal> GetUserAsync(bool useCache = false)
     {
         var now = DateTimeOffset.Now;
         if (useCache && now < _userLastCheck + UserCacheRefreshInterval)
@@ -41,13 +41,13 @@ private async ValueTask<ClaimsPrincipal> GetUser(bool useCache = false)
             return _cachedUser;
         }
 
-        _cachedUser = await FetchUser();
+        _cachedUser = await FetchUserAsync();
         _userLastCheck = now;
 
         return _cachedUser;
     }
 
-    private async Task<ClaimsPrincipal> FetchUser()
+    private async Task<ClaimsPrincipal> FetchUserAsync()
     {
         UserInfo user = null;
 
diff --git a/src/BlazorAdmin/JavaScript/Cookies.cs b/src/BlazorAdmin/JavaScript/Cookies.cs
index 7d8742cb7..7e0422f77 100644
--- a/src/BlazorAdmin/JavaScript/Cookies.cs
+++ b/src/BlazorAdmin/JavaScript/Cookies.cs
@@ -12,12 +12,12 @@ public Cookies(IJSRuntime jsRuntime)
         _jsRuntime = jsRuntime;
     }
 
-    public async Task DeleteCookie(string name)
+    public async Task DeleteCookieAsync(string name)
     {
         await _jsRuntime.InvokeAsync<string>(JSInteropConstants.DeleteCookie, name);
     }
 
-    public async Task<string> GetCookie(string name)
+    public async Task<string> GetCookieAsync(string name)
     {
         return await _jsRuntime.InvokeAsync<string>(JSInteropConstants.GetCookie, name);
     }
diff --git a/src/BlazorAdmin/JavaScript/Css.cs b/src/BlazorAdmin/JavaScript/Css.cs
index 11d8763bd..f9d7874d2 100644
--- a/src/BlazorAdmin/JavaScript/Css.cs
+++ b/src/BlazorAdmin/JavaScript/Css.cs
@@ -12,12 +12,12 @@ public Css(IJSRuntime jsRuntime)
         _jsRuntime = jsRuntime;
     }
 
-    public async Task ShowBodyOverflow()
+    public async Task ShowBodyOverflowAsync()
     {
         await _jsRuntime.InvokeAsync<string>(JSInteropConstants.ShowBodyOverflow);
     }
 
-    public async Task<string> HideBodyOverflow()
+    public async Task<string> HideBodyOverflowAsync()
     {
         return await _jsRuntime.InvokeAsync<string>(JSInteropConstants.HideBodyOverflow);
     }
diff --git a/src/BlazorAdmin/JavaScript/Route.cs b/src/BlazorAdmin/JavaScript/Route.cs
index 3694545ad..702349bb5 100644
--- a/src/BlazorAdmin/JavaScript/Route.cs
+++ b/src/BlazorAdmin/JavaScript/Route.cs
@@ -12,7 +12,7 @@ public Route(IJSRuntime jsRuntime)
         _jsRuntime = jsRuntime;
     }
 
-    public async Task RouteOutside(string path)
+    public async Task RouteOutsideAsync(string path)
     {
         await _jsRuntime.InvokeAsync<string>(JSInteropConstants.RouteOutside, path);
     }
diff --git a/src/BlazorAdmin/Pages/CatalogItemPage/Create.razor b/src/BlazorAdmin/Pages/CatalogItemPage/Create.razor
index 8bc5c23c1..eb99adfef 100644
--- a/src/BlazorAdmin/Pages/CatalogItemPage/Create.razor
+++ b/src/BlazorAdmin/Pages/CatalogItemPage/Create.razor
@@ -9,11 +9,11 @@
 <div class="modal @_modalClass" tabindex="-1" role="dialog" style="display:@_modalDisplay">
     <div class="modal-dialog" role="document">
         <div class="modal-content">
-            <EditForm Model="_item" OnValidSubmit="@CreateClick">
+            <EditForm Model="_item" OnValidSubmit="@CreateClickAsync">
                 <DataAnnotationsValidator />
                 <div class="modal-header">
                     <h5 class="modal-title" id="exampleModalLabel">Create</h5>
-                    <button type="button" class="close" data-dismiss="modal" aria-label="Close" @onclick="Close">
+                    <button type="button" class="close" data-dismiss="modal" aria-label="Close" @onclick="CloseAsync">
                         <span aria-hidden="true">&times;</span>
                     </button>
                 </div>
@@ -87,7 +87,7 @@
                     }
                 </div>
                 <div class="modal-footer">
-                    <button type="button" class="btn btn-secondary" data-dismiss="modal" @onclick="Close">Cancel</button>
+                    <button type="button" class="btn btn-secondary" data-dismiss="modal" @onclick="CloseAsync">Cancel</button>
                     <button type="submit" class="btn btn-primary">
                         Create
                     </button>
@@ -122,22 +122,22 @@
     private bool _showCreateModal = false;
     private CreateCatalogItemRequest _item = new CreateCatalogItemRequest();
 
-    private async Task CreateClick()
+    private async Task CreateClickAsync()
     {
-        var result = await CatalogItemService.Create(_item);
+        var result = await CatalogItemService.CreateAsync(_item);
         if (result != null)
         {
             await OnSaveClick.InvokeAsync(null);
-            await Close();
+            await CloseAsync();
         }
     }
 
-    public async Task Open()
+    public async Task OpenAsync()
     {
     
         Logger.LogInformation("Now loading... /Catalog/Create");
 
-        await new Css(JSRuntime).HideBodyOverflow();
+        await new Css(JSRuntime).HideBodyOverflowAsync();
 
         _item = new CreateCatalogItemRequest
         {
@@ -152,9 +152,9 @@
         StateHasChanged();
     }
 
-    private async Task Close()
+    private async Task CloseAsync()
     {
-        await new Css(JSRuntime).ShowBodyOverflow();
+        await new Css(JSRuntime).ShowBodyOverflowAsync();
         _modalDisplay = "none";
         _modalClass = "";
         _showCreateModal = false;
diff --git a/src/BlazorAdmin/Pages/CatalogItemPage/Delete.razor b/src/BlazorAdmin/Pages/CatalogItemPage/Delete.razor
index 5791195d9..7916a7d71 100644
--- a/src/BlazorAdmin/Pages/CatalogItemPage/Delete.razor
+++ b/src/BlazorAdmin/Pages/CatalogItemPage/Delete.razor
@@ -11,7 +11,7 @@
         <div class="modal-content">
             <div class="modal-header">
                 <h5 class="modal-title" id="exampleModalLabel">Delete @_item.Name</h5>
-                <button type="button" class="close" data-dismiss="modal" aria-label="Close" @onclick="Close">
+                <button type="button" class="close" data-dismiss="modal" aria-label="Close" @onclick="CloseAsync">
                     <span aria-hidden="true">&times;</span>
                 </button>
             </div>
@@ -75,8 +75,8 @@
 
             </div>
             <div class="modal-footer">
-                <button type="button" class="btn btn-secondary" data-dismiss="modal" @onclick="Close">Cancel</button>
-                <button class="btn btn-danger" @onclick="() => DeleteClick(_item.Id)">
+                <button type="button" class="btn btn-secondary" data-dismiss="modal" @onclick="CloseAsync">Cancel</button>
+                <button class="btn btn-danger" @onclick="() => DeleteClickAsync(_item.Id)">
                     Delete
                 </button>
             </div>
@@ -105,23 +105,23 @@
     private bool _showDeleteModal = false;
     private CatalogItem _item = new CatalogItem();
 
-    private async Task DeleteClick(int id)
+    private async Task DeleteClickAsync(int id)
     {
         // TODO: Add some kind of "are you sure" check before this
 
-        await CatalogItemService.Delete(id);
+        await CatalogItemService.DeleteAsync(id);
 
         await OnSaveClick.InvokeAsync(null);
-        await Close();
+        await CloseAsync();
     }
 
-    public async Task Open(int id)
+    public async Task OpenAsync(int id)
     {
         Logger.LogInformation("Now loading... /Catalog/Delete/{Id}", id);
 
-        await new Css(JSRuntime).HideBodyOverflow();
+        await new Css(JSRuntime).HideBodyOverflowAsync();
 
-        _item = await CatalogItemService.GetById(id);
+        _item = await CatalogItemService.GetByIdAsync(id);
 
         _modalDisplay = "block;";
         _modalClass = "Show";
@@ -130,9 +130,9 @@
         StateHasChanged();
     }
 
-    private async Task Close()
+    private async Task CloseAsync()
     {
-        await new Css(JSRuntime).ShowBodyOverflow();
+        await new Css(JSRuntime).ShowBodyOverflowAsync();
         _modalDisplay = "none";
         _modalClass = "";
         _showDeleteModal = false;
diff --git a/src/BlazorAdmin/Pages/CatalogItemPage/Details.razor b/src/BlazorAdmin/Pages/CatalogItemPage/Details.razor
index c48837321..e05393ba6 100644
--- a/src/BlazorAdmin/Pages/CatalogItemPage/Details.razor
+++ b/src/BlazorAdmin/Pages/CatalogItemPage/Details.razor
@@ -11,7 +11,7 @@
         <div class="modal-content">
             <div class="modal-header">
                 <h5 class="modal-title" id="exampleModalLabel">Details @_item.Name</h5>
-                <button type="button" class="close" data-dismiss="modal" aria-label="Close" @onclick="Close">
+                <button type="button" class="close" data-dismiss="modal" aria-label="Close" @onclick="CloseAsync">
                     <span aria-hidden="true">&times;</span>
                 </button>
             </div>
@@ -79,8 +79,8 @@
 
             </div>
             <div class="modal-footer">
-                <button type="button" class="btn btn-secondary" data-dismiss="modal" @onclick="Close">Close</button>
-                <button class="btn btn-primary" @onclick="EditClick">
+                <button type="button" class="btn btn-secondary" data-dismiss="modal" @onclick="CloseAsync">Close</button>
+                <button class="btn btn-primary" @onclick="EditClickAsync">
                     Edit
                 </button>
             </div>
@@ -108,20 +108,20 @@
     private bool _showDetailsModal = false;
     private CatalogItem _item = new CatalogItem();
 
-    public async Task EditClick()
+    public async Task EditClickAsync()
     {
         await OnEditClick.InvokeAsync(_item.Id);
-        await Close();
+        await CloseAsync();
     }
 
-    public async Task Open(int id)
+    public async Task OpenAsync(int id)
     {
 
         Logger.LogInformation("Now loading... /Catalog/Details/{Id}", id);
 
-        await new Css(JSRuntime).HideBodyOverflow();
+        await new Css(JSRuntime).HideBodyOverflowAsync();
 
-        _item = await CatalogItemService.GetById(id);
+        _item = await CatalogItemService.GetByIdAsync(id);
 
         _modalDisplay = "block;";
         _modalClass = "Show";
@@ -130,9 +130,9 @@
         StateHasChanged();
     }
 
-    public async Task Close()
+    public async Task CloseAsync()
     {
-        await new Css(JSRuntime).ShowBodyOverflow();
+        await new Css(JSRuntime).ShowBodyOverflowAsync();
 
         _modalDisplay = "none";
         _modalClass = "";
diff --git a/src/BlazorAdmin/Pages/CatalogItemPage/Edit.razor b/src/BlazorAdmin/Pages/CatalogItemPage/Edit.razor
index 9ae161c74..62866d8e7 100644
--- a/src/BlazorAdmin/Pages/CatalogItemPage/Edit.razor
+++ b/src/BlazorAdmin/Pages/CatalogItemPage/Edit.razor
@@ -9,11 +9,11 @@
 <div class="modal @_modalClass" tabindex="-1" role="dialog" style="display:@_modalDisplay">
     <div class="modal-dialog" role="document">
         <div class="modal-content">
-            <EditForm Model="_item" OnValidSubmit="@SaveClick">
+            <EditForm Model="_item" OnValidSubmit="@SaveClickAsync">
                 <DataAnnotationsValidator />
                 <div class="modal-header">
                     <h5 class="modal-title" id="exampleModalLabel">Edit @_item.Name</h5>
-                    <button type="button" class="close" data-dismiss="modal" aria-label="Close" @onclick="Close">
+                    <button type="button" class="close" data-dismiss="modal" aria-label="Close" @onclick="CloseAsync">
                         <span aria-hidden="true">&times;</span>
                     </button>
                 </div>
@@ -90,7 +90,7 @@
                     }
                 </div>
                 <div class="modal-footer">
-                    <button type="button" class="btn btn-secondary" data-dismiss="modal" @onclick="Close">Cancel</button>
+                    <button type="button" class="btn btn-secondary" data-dismiss="modal" @onclick="CloseAsync">Cancel</button>
                     <button type="submit" class="btn btn-primary">
                         Save
                     </button>
@@ -124,20 +124,20 @@
     private bool _showEditModal = false;
     private CatalogItem _item = new CatalogItem();
 
-    private async Task SaveClick()
+    private async Task SaveClickAsync()
     {
-        await CatalogItemService.Edit(_item);
+        await CatalogItemService.EditAsync(_item);
         await OnSaveClick.InvokeAsync(null);
-        await Close();
+        await CloseAsync();
     }
 
-    public async Task Open(int id)
+    public async Task OpenAsync(int id)
     {
         Logger.LogInformation("Now loading... /Catalog/Edit/{Id}", id);
 
-        await new Css(JSRuntime).HideBodyOverflow();
+        await new Css(JSRuntime).HideBodyOverflowAsync();
 
-        _item = await CatalogItemService.GetById(id);
+        _item = await CatalogItemService.GetByIdAsync(id);
 
         _modalDisplay = "block;";
         _modalClass = "Show";
@@ -146,9 +146,9 @@
         StateHasChanged();
     }
 
-    private async Task Close()
+    private async Task CloseAsync()
     {
-        await new Css(JSRuntime).ShowBodyOverflow();
+        await new Css(JSRuntime).ShowBodyOverflowAsync();
 
         _modalDisplay = "none";
         _modalClass = "";
diff --git a/src/BlazorAdmin/Pages/CatalogItemPage/List.razor b/src/BlazorAdmin/Pages/CatalogItemPage/List.razor
index 33d34c585..ef62d27e7 100644
--- a/src/BlazorAdmin/Pages/CatalogItemPage/List.razor
+++ b/src/BlazorAdmin/Pages/CatalogItemPage/List.razor
@@ -15,7 +15,7 @@ else
 {
 
     <p class="esh-link-wrapper">
-        <button class="btn btn-primary" @onclick="@(CreateClick)">
+        <button class="btn btn-primary" @onclick="@(CreateClickAsync)">
             Create New
         </button>
     </p>
@@ -36,7 +36,7 @@ else
         <tbody class="cursor-pointer">
             @foreach (var item in catalogItems)
             {
-                <tr @onclick="@(() => DetailsClick(item.Id))">
+                <tr @onclick="@(() => DetailsClickAsync(item.Id))">
                     <td>
                         <img class="img-thumbnail" src="@($"{item.PictureUri}")">
                     </td>
@@ -47,11 +47,11 @@ else
                     <td>@item.Description</td>
                     <td>@item.Price</td>
                     <td>
-                        <button @onclick="@(() => EditClick(item.Id))" @onclick:stopPropagation="true" class="btn btn-primary">
+                        <button @onclick="@(() => EditClickAsync(item.Id))" @onclick:stopPropagation="true" class="btn btn-primary">
                             Edit
                         </button>
 
-                        <button @onclick="@(() => DeleteClick(item.Id))" @onclick:stopPropagation="true" class="btn btn-danger">
+                        <button @onclick="@(() => DeleteClickAsync(item.Id))" @onclick:stopPropagation="true" class="btn btn-danger">
                             Delete
                         </button>
                     </td>
@@ -60,8 +60,8 @@ else
         </tbody>
     </table>
 
-    <Details Brands="@catalogBrands" Types="@catalogTypes" OnEditClick="EditClick" @ref="DetailsComponent"></Details>
-    <Edit Brands="@catalogBrands" Types="@catalogTypes" OnSaveClick="ReloadCatalogItems" @ref="EditComponent"></Edit>
-    <Create Brands="@catalogBrands" Types="@catalogTypes" OnSaveClick="ReloadCatalogItems" @ref="CreateComponent"></Create>
-    <Delete Brands="@catalogBrands" Types="@catalogTypes" OnSaveClick="ReloadCatalogItems" @ref="DeleteComponent"></Delete>
+    <Details Brands="@catalogBrands" Types="@catalogTypes" OnEditClick="EditClickAsync" @ref="DetailsComponent"></Details>
+    <Edit Brands="@catalogBrands" Types="@catalogTypes" OnSaveClick="ReloadCatalogItemsAsync" @ref="EditComponent"></Edit>
+    <Create Brands="@catalogBrands" Types="@catalogTypes" OnSaveClick="ReloadCatalogItemsAsync" @ref="CreateComponent"></Create>
+    <Delete Brands="@catalogBrands" Types="@catalogTypes" OnSaveClick="ReloadCatalogItemsAsync" @ref="DeleteComponent"></Delete>
 }
diff --git a/src/BlazorAdmin/Pages/CatalogItemPage/List.razor.cs b/src/BlazorAdmin/Pages/CatalogItemPage/List.razor.cs
index 05fcbc6ee..433c45436 100644
--- a/src/BlazorAdmin/Pages/CatalogItemPage/List.razor.cs
+++ b/src/BlazorAdmin/Pages/CatalogItemPage/List.razor.cs
@@ -30,9 +30,9 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
     {
         if (firstRender)
         {
-            catalogItems = await CatalogItemService.List();
-            catalogTypes = await CatalogTypeService.List();
-            catalogBrands = await CatalogBrandService.List();
+            catalogItems = await CatalogItemService.ListAsync();
+            catalogTypes = await CatalogTypeService.ListAsync();
+            catalogBrands = await CatalogBrandService.ListAsync();
 
             CallRequestRefresh();
         }
@@ -40,29 +40,29 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
         await base.OnAfterRenderAsync(firstRender);
     }
 
-    private async void DetailsClick(int id)
+    private async void DetailsClickAsync(int id)
     {
-        await DetailsComponent.Open(id);
+        await DetailsComponent.OpenAsync(id);
     }
 
-    private async Task CreateClick()
+    private async Task CreateClickAsync()
     {
-        await CreateComponent.Open();
+        await CreateComponent.OpenAsync();
     }
 
-    private async Task EditClick(int id)
+    private async Task EditClickAsync(int id)
     {
-        await EditComponent.Open(id);
+        await EditComponent.OpenAsync(id);
     }
 
-    private async Task DeleteClick(int id)
+    private async Task DeleteClickAsync(int id)
     {
-        await DeleteComponent.Open(id);
+        await DeleteComponent.OpenAsync(id);
     }
 
-    private async Task ReloadCatalogItems()
+    private async Task ReloadCatalogItemsAsync()
     {
-        catalogItems = await CatalogItemService.List();
+        catalogItems = await CatalogItemService.ListAsync();
         StateHasChanged();
     }
 }
diff --git a/src/BlazorAdmin/Pages/Logout.razor b/src/BlazorAdmin/Pages/Logout.razor
index ada679c71..920609f50 100644
--- a/src/BlazorAdmin/Pages/Logout.razor
+++ b/src/BlazorAdmin/Pages/Logout.razor
@@ -8,7 +8,7 @@
     protected override async Task OnInitializedAsync()
     {
         await HttpClient.PostAsync("User/Logout", null);
-        await new Route(JSRuntime).RouteOutside("/Identity/Account/Login");
+        await new Route(JSRuntime).RouteOutsideAsync("/Identity/Account/Login");
     }
 
 }
diff --git a/src/BlazorAdmin/Program.cs b/src/BlazorAdmin/Program.cs
index a6d4354d4..f3bdf2c3f 100644
--- a/src/BlazorAdmin/Program.cs
+++ b/src/BlazorAdmin/Program.cs
@@ -35,11 +35,11 @@
 
 builder.Logging.AddConfiguration(builder.Configuration.GetRequiredSection("Logging"));
 
-await ClearLocalStorageCache(builder.Services);
+await ClearLocalStorageCacheAsync(builder.Services);
 
 await builder.Build().RunAsync();
 
-static async Task ClearLocalStorageCache(IServiceCollection services)
+static async Task ClearLocalStorageCacheAsync(IServiceCollection services)
 {
     var sp = services.BuildServiceProvider();
     var localStorageService = sp.GetRequiredService<ILocalStorageService>();
diff --git a/src/BlazorAdmin/Services/CachedCatalogItemServiceDecorator.cs b/src/BlazorAdmin/Services/CachedCatalogItemServiceDecorator.cs
index a81d3c7bc..f121c63c7 100644
--- a/src/BlazorAdmin/Services/CachedCatalogItemServiceDecorator.cs
+++ b/src/BlazorAdmin/Services/CachedCatalogItemServiceDecorator.cs
@@ -24,7 +24,7 @@ public CachedCatalogItemServiceDecorator(ILocalStorageService localStorageServic
         _logger = logger;
     }
 
-    public async Task<List<CatalogItem>> ListPaged(int pageSize)
+    public async Task<List<CatalogItem>> ListPagedAsync(int pageSize)
     {
         string key = "items";
         var cacheEntry = await _localStorageService.GetItemAsync<CacheEntry<List<CatalogItem>>>(key);
@@ -42,13 +42,13 @@ public async Task<List<CatalogItem>> ListPaged(int pageSize)
             }
         }
 
-        var items = await _catalogItemService.ListPaged(pageSize);
+        var items = await _catalogItemService.ListPagedAsync(pageSize);
         var entry = new CacheEntry<List<CatalogItem>>(items);
         await _localStorageService.SetItemAsync(key, entry);
         return items;
     }
 
-    public async Task<List<CatalogItem>> List()
+    public async Task<List<CatalogItem>> ListAsync()
     {
         string key = "items";
         var cacheEntry = await _localStorageService.GetItemAsync<CacheEntry<List<CatalogItem>>>(key);
@@ -66,47 +66,47 @@ public async Task<List<CatalogItem>> List()
             }
         }
 
-        var items = await _catalogItemService.List();
+        var items = await _catalogItemService.ListAsync();
         var entry = new CacheEntry<List<CatalogItem>>(items);
         await _localStorageService.SetItemAsync(key, entry);
         return items;
     }
 
-    public async Task<CatalogItem> GetById(int id)
+    public async Task<CatalogItem> GetByIdAsync(int id)
     {
-        return (await List()).FirstOrDefault(x => x.Id == id);
+        return (await ListAsync()).FirstOrDefault(x => x.Id == id);
     }
 
-    public async Task<CatalogItem> Create(CreateCatalogItemRequest catalogItem)
+    public async Task<CatalogItem> CreateAsync(CreateCatalogItemRequest catalogItem)
     {
-        var result = await _catalogItemService.Create(catalogItem);
-        await RefreshLocalStorageList();
+        var result = await _catalogItemService.CreateAsync(catalogItem);
+        await RefreshLocalStorageListAsync();
 
         return result;
     }
 
-    public async Task<CatalogItem> Edit(CatalogItem catalogItem)
+    public async Task<CatalogItem> EditAsync(CatalogItem catalogItem)
     {
-        var result = await _catalogItemService.Edit(catalogItem);
-        await RefreshLocalStorageList();
+        var result = await _catalogItemService.EditAsync(catalogItem);
+        await RefreshLocalStorageListAsync();
 
         return result;
     }
 
-    public async Task<string> Delete(int id)
+    public async Task<string> DeleteAsync(int id)
     {
-        var result = await _catalogItemService.Delete(id);
-        await RefreshLocalStorageList();
+        var result = await _catalogItemService.DeleteAsync(id);
+        await RefreshLocalStorageListAsync();
 
         return result;
     }
 
-    private async Task RefreshLocalStorageList()
+    private async Task RefreshLocalStorageListAsync()
     {
         string key = "items";
 
         await _localStorageService.RemoveItemAsync(key);
-        var items = await _catalogItemService.List();
+        var items = await _catalogItemService.ListAsync();
         var entry = new CacheEntry<List<CatalogItem>>(items);
         await _localStorageService.SetItemAsync(key, entry);
     }
diff --git a/src/BlazorAdmin/Services/CachedCatalogLookupDataServiceDecorator .cs b/src/BlazorAdmin/Services/CachedCatalogLookupDataServiceDecorator .cs
index 767763c6b..8a072c257 100644
--- a/src/BlazorAdmin/Services/CachedCatalogLookupDataServiceDecorator .cs	
+++ b/src/BlazorAdmin/Services/CachedCatalogLookupDataServiceDecorator .cs	
@@ -26,7 +26,7 @@ public CachedCatalogLookupDataServiceDecorator(ILocalStorageService localStorage
         _logger = logger;
     }
 
-    public async Task<List<TLookupData>> List()
+    public async Task<List<TLookupData>> ListAsync()
     {
         string key = typeof(TLookupData).Name;
         var cacheEntry = await _localStorageService.GetItemAsync<CacheEntry<List<TLookupData>>>(key);
@@ -44,7 +44,7 @@ public async Task<List<TLookupData>> List()
             }
         }
 
-        var types = await _catalogTypeService.List();
+        var types = await _catalogTypeService.ListAsync();
         var entry = new CacheEntry<List<TLookupData>>(types);
         await _localStorageService.SetItemAsync(key, entry);
         return types;
diff --git a/src/BlazorAdmin/Services/CatalogItemService.cs b/src/BlazorAdmin/Services/CatalogItemService.cs
index f3ebfd8c3..41e804808 100644
--- a/src/BlazorAdmin/Services/CatalogItemService.cs
+++ b/src/BlazorAdmin/Services/CatalogItemService.cs
@@ -26,27 +26,27 @@ public CatalogItemService(ICatalogLookupDataService<CatalogBrand> brandService,
         _logger = logger;
     }
 
-    public async Task<CatalogItem> Create(CreateCatalogItemRequest catalogItem)
+    public async Task<CatalogItem> CreateAsync(CreateCatalogItemRequest catalogItem)
     {
-        var response = await _httpService.HttpPost<CreateCatalogItemResponse>("catalog-items", catalogItem);
+        var response = await _httpService.HttpPostAsync<CreateCatalogItemResponse>("catalog-items", catalogItem);
         return response?.CatalogItem;
     }
 
-    public async Task<CatalogItem> Edit(CatalogItem catalogItem)
+    public async Task<CatalogItem> EditAsync(CatalogItem catalogItem)
     {
-        return (await _httpService.HttpPut<EditCatalogItemResult>("catalog-items", catalogItem)).CatalogItem;
+        return (await _httpService.HttpPutAsync<EditCatalogItemResult>("catalog-items", catalogItem)).CatalogItem;
     }
 
-    public async Task<string> Delete(int catalogItemId)
+    public async Task<string> DeleteAsync(int catalogItemId)
     {
-        return (await _httpService.HttpDelete<DeleteCatalogItemResponse>("catalog-items", catalogItemId)).Status;
+        return (await _httpService.HttpDeleteAsync<DeleteCatalogItemResponse>("catalog-items", catalogItemId)).Status;
     }
 
-    public async Task<CatalogItem> GetById(int id)
+    public async Task<CatalogItem> GetByIdAsync(int id)
     {
-        var brandListTask = _brandService.List();
-        var typeListTask = _typeService.List();
-        var itemGetTask = _httpService.HttpGet<EditCatalogItemResult>($"catalog-items/{id}");
+        var brandListTask = _brandService.ListAsync();
+        var typeListTask = _typeService.ListAsync();
+        var itemGetTask = _httpService.HttpGetAsync<EditCatalogItemResult>($"catalog-items/{id}");
         await Task.WhenAll(brandListTask, typeListTask, itemGetTask);
         var brands = brandListTask.Result;
         var types = typeListTask.Result;
@@ -56,13 +56,13 @@ public async Task<CatalogItem> GetById(int id)
         return catalogItem;
     }
 
-    public async Task<List<CatalogItem>> ListPaged(int pageSize)
+    public async Task<List<CatalogItem>> ListPagedAsync(int pageSize)
     {
         _logger.LogInformation("Fetching catalog items from API.");
 
-        var brandListTask = _brandService.List();
-        var typeListTask = _typeService.List();
-        var itemListTask = _httpService.HttpGet<PagedCatalogItemResponse>($"catalog-items?PageSize=10");
+        var brandListTask = _brandService.ListAsync();
+        var typeListTask = _typeService.ListAsync();
+        var itemListTask = _httpService.HttpGetAsync<PagedCatalogItemResponse>($"catalog-items?PageSize=10");
         await Task.WhenAll(brandListTask, typeListTask, itemListTask);
         var brands = brandListTask.Result;
         var types = typeListTask.Result;
@@ -75,13 +75,13 @@ public async Task<List<CatalogItem>> ListPaged(int pageSize)
         return items;
     }
 
-    public async Task<List<CatalogItem>> List()
+    public async Task<List<CatalogItem>> ListAsync()
     {
         _logger.LogInformation("Fetching catalog items from API.");
 
-        var brandListTask = _brandService.List();
-        var typeListTask = _typeService.List();
-        var itemListTask = _httpService.HttpGet<PagedCatalogItemResponse>($"catalog-items");
+        var brandListTask = _brandService.ListAsync();
+        var typeListTask = _typeService.ListAsync();
+        var itemListTask = _httpService.HttpGetAsync<PagedCatalogItemResponse>($"catalog-items");
         await Task.WhenAll(brandListTask, typeListTask, itemListTask);
         var brands = brandListTask.Result;
         var types = typeListTask.Result;
diff --git a/src/BlazorAdmin/Services/CatalogLookupDataService.cs b/src/BlazorAdmin/Services/CatalogLookupDataService.cs
index fa06b1608..744d822d2 100644
--- a/src/BlazorAdmin/Services/CatalogLookupDataService.cs
+++ b/src/BlazorAdmin/Services/CatalogLookupDataService.cs
@@ -32,7 +32,7 @@ public CatalogLookupDataService(HttpClient httpClient,
         _apiUrl = baseUrlConfiguration.Value.ApiBase;
     }
 
-    public async Task<List<TLookupData>> List()
+    public async Task<List<TLookupData>> ListAsync()
     {
         var endpointName = typeof(TLookupData).GetCustomAttribute<EndpointAttribute>().Name;
         _logger.LogInformation($"Fetching {typeof(TLookupData).Name} from API. Enpoint : {endpointName}");
diff --git a/src/BlazorAdmin/Services/HttpService.cs b/src/BlazorAdmin/Services/HttpService.cs
index 2362e9e5d..c90ea089c 100644
--- a/src/BlazorAdmin/Services/HttpService.cs
+++ b/src/BlazorAdmin/Services/HttpService.cs
@@ -22,7 +22,7 @@ public HttpService(HttpClient httpClient, IOptions<BaseUrlConfiguration> baseUrl
         _apiUrl = baseUrlConfiguration.Value.ApiBase;
     }
 
-    public async Task<T> HttpGet<T>(string uri)
+    public async Task<T> HttpGetAsync<T>(string uri)
         where T : class
     {
         var result = await _httpClient.GetAsync($"{_apiUrl}{uri}");
@@ -31,10 +31,10 @@ public async Task<T> HttpGet<T>(string uri)
             return null;
         }
 
-        return await FromHttpResponseMessage<T>(result);
+        return await FromHttpResponseMessageAsync<T>(result);
     }
 
-    public async Task<T> HttpDelete<T>(string uri, int id)
+    public async Task<T> HttpDeleteAsync<T>(string uri, int id)
         where T : class
     {
         var result = await _httpClient.DeleteAsync($"{_apiUrl}{uri}/{id}");
@@ -43,10 +43,10 @@ public async Task<T> HttpDelete<T>(string uri, int id)
             return null;
         }
 
-        return await FromHttpResponseMessage<T>(result);
+        return await FromHttpResponseMessageAsync<T>(result);
     }
 
-    public async Task<T> HttpPost<T>(string uri, object dataToSend)
+    public async Task<T> HttpPostAsync<T>(string uri, object dataToSend)
         where T : class
     {
         var content = ToJson(dataToSend);
@@ -63,10 +63,10 @@ public async Task<T> HttpPost<T>(string uri, object dataToSend)
             return null;
         }
 
-        return await FromHttpResponseMessage<T>(result);
+        return await FromHttpResponseMessageAsync<T>(result);
     }
 
-    public async Task<T> HttpPut<T>(string uri, object dataToSend)
+    public async Task<T> HttpPutAsync<T>(string uri, object dataToSend)
         where T : class
     {
         var content = ToJson(dataToSend);
@@ -78,7 +78,7 @@ public async Task<T> HttpPut<T>(string uri, object dataToSend)
             return null;
         }
 
-        return await FromHttpResponseMessage<T>(result);
+        return await FromHttpResponseMessageAsync<T>(result);
     }
 
     private StringContent ToJson(object obj)
@@ -86,7 +86,7 @@ private StringContent ToJson(object obj)
         return new StringContent(JsonSerializer.Serialize(obj), Encoding.UTF8, "application/json");
     }
 
-    private async Task<T> FromHttpResponseMessage<T>(HttpResponseMessage result)
+    private async Task<T> FromHttpResponseMessageAsync<T>(HttpResponseMessage result)
     {
         return JsonSerializer.Deserialize<T>(await result.Content.ReadAsStringAsync(), new JsonSerializerOptions
         {
diff --git a/src/BlazorAdmin/Shared/MainLayout.razor b/src/BlazorAdmin/Shared/MainLayout.razor
index a7d8383de..ebde6d6ca 100644
--- a/src/BlazorAdmin/Shared/MainLayout.razor
+++ b/src/BlazorAdmin/Shared/MainLayout.razor
@@ -31,7 +31,7 @@
 
                 if (authState.User == null)
                 {
-                    await new Route(JSRuntime).RouteOutside("/Identity/Account/Login");
+                await new Route(JSRuntime).RouteOutsideAsync("/Identity/Account/Login");
                 }
                 CallRequestRefresh();
             }
diff --git a/src/BlazorShared/Interfaces/ICatalogItemService.cs b/src/BlazorShared/Interfaces/ICatalogItemService.cs
index 7fd03301f..d0924fafb 100644
--- a/src/BlazorShared/Interfaces/ICatalogItemService.cs
+++ b/src/BlazorShared/Interfaces/ICatalogItemService.cs
@@ -6,10 +6,10 @@ namespace BlazorShared.Interfaces;
 
 public interface ICatalogItemService
 {
-    Task<CatalogItem> Create(CreateCatalogItemRequest catalogItem);
-    Task<CatalogItem> Edit(CatalogItem catalogItem);
-    Task<string> Delete(int id);
-    Task<CatalogItem> GetById(int id);
-    Task<List<CatalogItem>> ListPaged(int pageSize);
-    Task<List<CatalogItem>> List();
+    Task<CatalogItem> CreateAsync(CreateCatalogItemRequest catalogItem);
+    Task<CatalogItem> EditAsync(CatalogItem catalogItem);
+    Task<string> DeleteAsync(int id);
+    Task<CatalogItem> GetByIdAsync(int id);
+    Task<List<CatalogItem>> ListPagedAsync(int pageSize);
+    Task<List<CatalogItem>> ListAsync();
 }
diff --git a/src/BlazorShared/Interfaces/ICatalogLookupDataService.cs b/src/BlazorShared/Interfaces/ICatalogLookupDataService.cs
index ed6a35987..18afb0202 100644
--- a/src/BlazorShared/Interfaces/ICatalogLookupDataService.cs
+++ b/src/BlazorShared/Interfaces/ICatalogLookupDataService.cs
@@ -6,5 +6,5 @@ namespace BlazorShared.Interfaces;
 
 public interface ICatalogLookupDataService<TLookupData> where TLookupData : LookupData
 {
-    Task<List<TLookupData>> List();
+    Task<List<TLookupData>> ListAsync();
 }
diff --git a/src/BlazorShared/Models/CatalogItem.cs b/src/BlazorShared/Models/CatalogItem.cs
index efc3bd1b4..e050649f9 100644
--- a/src/BlazorShared/Models/CatalogItem.cs
+++ b/src/BlazorShared/Models/CatalogItem.cs
@@ -60,7 +60,7 @@ public static string IsValidImage(string pictureName, string pictureBase64)
         return null;
     }
 
-    public static async Task<string> DataToBase64(IFileListEntry fileItem)
+    public static async Task<string> DataToBase64Async(IFileListEntry fileItem)
     {
         using (var reader = new StreamReader(fileItem.Data))
         {
diff --git a/src/Infrastructure/Data/Queries/BasketQueryService.cs b/src/Infrastructure/Data/Queries/BasketQueryService.cs
index 9f6c4d912..9b4d889dc 100644
--- a/src/Infrastructure/Data/Queries/BasketQueryService.cs
+++ b/src/Infrastructure/Data/Queries/BasketQueryService.cs
@@ -19,7 +19,7 @@ public BasketQueryService(CatalogContext dbContext)
     /// </summary>
     /// <param name="username"></param>
     /// <returns></returns>
-    public async Task<int> CountTotalBasketItems(string username)
+    public async Task<int> CountTotalBasketItemsAsync(string username)
     {
         var totalItems = await _dbContext.Baskets
             .Where(basket => basket.BuyerId == username)
diff --git a/src/Web/Areas/Identity/Pages/Account/Logout.cshtml.cs b/src/Web/Areas/Identity/Pages/Account/Logout.cshtml.cs
index 80bb4670e..7864461f4 100644
--- a/src/Web/Areas/Identity/Pages/Account/Logout.cshtml.cs
+++ b/src/Web/Areas/Identity/Pages/Account/Logout.cshtml.cs
@@ -28,7 +28,7 @@ public void OnGet()
     {
     }
 
-    public async Task<IActionResult> OnPost(string? returnUrl = null)
+    public async Task<IActionResult> OnPostAsync(string? returnUrl = null)
     {
         await _signInManager.SignOutAsync();
         await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
diff --git a/src/Web/Controllers/ManageController.cs b/src/Web/Controllers/ManageController.cs
index d97473c33..095c9b64f 100644
--- a/src/Web/Controllers/ManageController.cs
+++ b/src/Web/Controllers/ManageController.cs
@@ -44,7 +44,7 @@ public ManageController(
     public string? StatusMessage { get; set; }
 
     [HttpGet]
-    public async Task<IActionResult> MyAccount()
+    public async Task<IActionResult> MyAccountAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -66,7 +66,7 @@ public async Task<IActionResult> MyAccount()
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> MyAccount(IndexViewModel model)
+    public async Task<IActionResult> MyAccountAsync(IndexViewModel model)
     {
         if (!ModelState.IsValid)
         {
@@ -100,12 +100,12 @@ public async Task<IActionResult> MyAccount(IndexViewModel model)
         }
 
         StatusMessage = "Your profile has been updated";
-        return RedirectToAction(nameof(MyAccount));
+        return RedirectToAction(nameof(MyAccountAsync));
     }
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> SendVerificationEmail(IndexViewModel model)
+    public async Task<IActionResult> SendVerificationEmailAsync(IndexViewModel model)
     {
         if (!ModelState.IsValid)
         {
@@ -130,11 +130,11 @@ public async Task<IActionResult> SendVerificationEmail(IndexViewModel model)
         await _emailSender.SendEmailConfirmationAsync(email, callbackUrl);
 
         StatusMessage = "Verification email sent. Please check your email.";
-        return RedirectToAction(nameof(MyAccount));
+        return RedirectToAction(nameof(MyAccountAsync));
     }
 
     [HttpGet]
-    public async Task<IActionResult> ChangePassword()
+    public async Task<IActionResult> ChangePasswordAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -145,7 +145,7 @@ public async Task<IActionResult> ChangePassword()
         var hasPassword = await _userManager.HasPasswordAsync(user);
         if (!hasPassword)
         {
-            return RedirectToAction(nameof(SetPassword));
+            return RedirectToAction(nameof(SetPasswordAsync));
         }
 
         var model = new ChangePasswordViewModel { StatusMessage = StatusMessage };
@@ -154,7 +154,7 @@ public async Task<IActionResult> ChangePassword()
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model)
+    public async Task<IActionResult> ChangePasswordAsync(ChangePasswordViewModel model)
     {
         if (!ModelState.IsValid)
         {
@@ -179,11 +179,11 @@ public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model)
         _logger.LogInformation("User changed their password successfully.");
         StatusMessage = "Your password has been changed.";
 
-        return RedirectToAction(nameof(ChangePassword));
+        return RedirectToAction(nameof(ChangePasswordAsync));
     }
 
     [HttpGet]
-    public async Task<IActionResult> SetPassword()
+    public async Task<IActionResult> SetPasswordAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -195,7 +195,7 @@ public async Task<IActionResult> SetPassword()
 
         if (hasPassword)
         {
-            return RedirectToAction(nameof(ChangePassword));
+            return RedirectToAction(nameof(ChangePasswordAsync));
         }
 
         var model = new SetPasswordViewModel { StatusMessage = StatusMessage };
@@ -204,7 +204,7 @@ public async Task<IActionResult> SetPassword()
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> SetPassword(SetPasswordViewModel model)
+    public async Task<IActionResult> SetPasswordAsync(SetPasswordViewModel model)
     {
         if (!ModelState.IsValid)
         {
@@ -227,11 +227,11 @@ public async Task<IActionResult> SetPassword(SetPasswordViewModel model)
         await _signInManager.SignInAsync(user, isPersistent: false);
         StatusMessage = "Your password has been set.";
 
-        return RedirectToAction(nameof(SetPassword));
+        return RedirectToAction(nameof(SetPasswordAsync));
     }
 
     [HttpGet]
-    public async Task<IActionResult> ExternalLogins()
+    public async Task<IActionResult> ExternalLoginsAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -251,19 +251,19 @@ public async Task<IActionResult> ExternalLogins()
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> LinkLogin(string provider)
+    public async Task<IActionResult> LinkLoginAsync(string provider)
     {
         // Clear the existing external cookie to ensure a clean login process
         await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
 
         // Request a redirect to the external login provider to link a login for the current user
-        var redirectUrl = Url.Action(nameof(LinkLoginCallback));
+        var redirectUrl = Url.Action(nameof(LinkLoginCallbackAsync));
         var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl, _userManager.GetUserId(User));
         return new ChallengeResult(provider, properties);
     }
 
     [HttpGet]
-    public async Task<IActionResult> LinkLoginCallback()
+    public async Task<IActionResult> LinkLoginCallbackAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -287,12 +287,12 @@ public async Task<IActionResult> LinkLoginCallback()
         await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
 
         StatusMessage = "The external login was added.";
-        return RedirectToAction(nameof(ExternalLogins));
+        return RedirectToAction(nameof(ExternalLoginsAsync));
     }
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> RemoveLogin(RemoveLoginViewModel model)
+    public async Task<IActionResult> RemoveLoginAsync(RemoveLoginViewModel model)
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -312,11 +312,11 @@ public async Task<IActionResult> RemoveLogin(RemoveLoginViewModel model)
 
         await _signInManager.SignInAsync(user, isPersistent: false);
         StatusMessage = "The external login was removed.";
-        return RedirectToAction(nameof(ExternalLogins));
+        return RedirectToAction(nameof(ExternalLoginsAsync));
     }
 
     [HttpGet]
-    public async Task<IActionResult> TwoFactorAuthentication()
+    public async Task<IActionResult> TwoFactorAuthenticationAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -335,7 +335,7 @@ public async Task<IActionResult> TwoFactorAuthentication()
     }
 
     [HttpGet]
-    public async Task<IActionResult> Disable2faWarning()
+    public async Task<IActionResult> Disable2faWarningAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -348,12 +348,12 @@ public async Task<IActionResult> Disable2faWarning()
             throw new ApplicationException($"Unexpected error occured disabling 2FA for user with ID '{user.Id}'.");
         }
 
-        return View(nameof(Disable2fa));
+        return View(nameof(Disable2faAsync));
     }
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> Disable2fa()
+    public async Task<IActionResult> Disable2faAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -368,11 +368,11 @@ public async Task<IActionResult> Disable2fa()
         }
 
         _logger.LogInformation("User with ID {UserId} has disabled 2fa.", user.Id);
-        return RedirectToAction(nameof(TwoFactorAuthentication));
+        return RedirectToAction(nameof(TwoFactorAuthenticationAsync));
     }
 
     [HttpGet]
-    public async Task<IActionResult> EnableAuthenticator()
+    public async Task<IActionResult> EnableAuthenticatorAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -392,7 +392,7 @@ public IActionResult ShowRecoveryCodes()
         var recoveryCodes = (string[]?)TempData[RecoveryCodesKey];
         if (recoveryCodes == null)
         {
-            return RedirectToAction(nameof(TwoFactorAuthentication));
+            return RedirectToAction(nameof(TwoFactorAuthenticationAsync));
         }
 
         var model = new ShowRecoveryCodesViewModel { RecoveryCodes = recoveryCodes };
@@ -402,7 +402,7 @@ public IActionResult ShowRecoveryCodes()
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> EnableAuthenticator(EnableAuthenticatorViewModel model)
+    public async Task<IActionResult> EnableAuthenticatorAsync(EnableAuthenticatorViewModel model)
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -440,12 +440,12 @@ public async Task<IActionResult> EnableAuthenticator(EnableAuthenticatorViewMode
     [HttpGet]
     public IActionResult ResetAuthenticatorWarning()
     {
-        return View(nameof(ResetAuthenticator));
+        return View(nameof(ResetAuthenticatorAsync));
     }
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> ResetAuthenticator()
+    public async Task<IActionResult> ResetAuthenticatorAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -457,12 +457,12 @@ public async Task<IActionResult> ResetAuthenticator()
         await _userManager.ResetAuthenticatorKeyAsync(user);
         _logger.LogInformation("User with id '{UserId}' has reset their authentication app key.", user.Id);
 
-        return RedirectToAction(nameof(EnableAuthenticator));
+        return RedirectToAction(nameof(EnableAuthenticatorAsync));
     }
 
     [HttpPost]
     [ValidateAntiForgeryToken]
-    public async Task<IActionResult> GenerateRecoveryCodes()
+    public async Task<IActionResult> GenerateRecoveryCodesAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -484,7 +484,7 @@ public async Task<IActionResult> GenerateRecoveryCodes()
     }
 
     [HttpGet]
-    public async Task<IActionResult> GenerateRecoveryCodesWarning()
+    public async Task<IActionResult> GenerateRecoveryCodesWarningAsync()
     {
         var user = await _userManager.GetUserAsync(User);
         if (user == null)
@@ -497,7 +497,7 @@ public async Task<IActionResult> GenerateRecoveryCodesWarning()
             throw new ApplicationException($"Cannot generate recovery codes for user with ID '{user.Id}' because they do not have 2FA enabled.");
         }
 
-        return View(nameof(GenerateRecoveryCodesWarning));
+        return View(nameof(GenerateRecoveryCodesWarningAsync));
     }
 
     private void AddErrors(IdentityResult result)
diff --git a/src/Web/Controllers/OrderController.cs b/src/Web/Controllers/OrderController.cs
index 5a2e1e1c4..4f6f203eb 100644
--- a/src/Web/Controllers/OrderController.cs
+++ b/src/Web/Controllers/OrderController.cs
@@ -20,7 +20,7 @@ public OrderController(IMediator mediator)
     }
 
     [HttpGet]
-    public async Task<IActionResult> MyOrders()
+    public async Task<IActionResult> MyOrdersAsync()
     {   
         Guard.Against.Null(User?.Identity?.Name, nameof(User.Identity.Name));
         var viewModel = await _mediator.Send(new GetMyOrders(User.Identity.Name));
@@ -29,7 +29,7 @@ public async Task<IActionResult> MyOrders()
     }
 
     [HttpGet("{orderId}")]
-    public async Task<IActionResult> Detail(int orderId)
+    public async Task<IActionResult> DetailAsync(int orderId)
     {
         Guard.Against.Null(User?.Identity?.Name, nameof(User.Identity.Name));
         var viewModel = await _mediator.Send(new GetOrderDetails(User.Identity.Name, orderId));
diff --git a/src/Web/Controllers/UserController.cs b/src/Web/Controllers/UserController.cs
index 79968c18b..d7224c2ec 100644
--- a/src/Web/Controllers/UserController.cs
+++ b/src/Web/Controllers/UserController.cs
@@ -35,14 +35,14 @@ public UserController(ITokenClaimsService tokenClaimsService,
     [HttpGet]
     [Authorize]
     [AllowAnonymous]
-    public async Task<IActionResult> GetCurrentUser() =>
-        Ok(await CreateUserInfo(User));
+    public async Task<IActionResult> GetCurrentUserAsync() =>
+        Ok(await CreateUserInfoAsync(User));
 
     [Route("Logout")]
     [HttpPost]
     [Authorize]
     [AllowAnonymous]
-    public async Task<IActionResult> Logout()
+    public async Task<IActionResult> LogoutAsync()
     {
         await _signInManager.SignOutAsync();
         await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
@@ -57,7 +57,7 @@ public async Task<IActionResult> Logout()
         return Ok();
     }
 
-    private async Task<UserInfo> CreateUserInfo(ClaimsPrincipal claimsPrincipal)
+    private async Task<UserInfo> CreateUserInfoAsync(ClaimsPrincipal claimsPrincipal)
     {
         if (claimsPrincipal.Identity == null || claimsPrincipal.Identity.Name == null || !claimsPrincipal.Identity.IsAuthenticated)
         {
diff --git a/src/Web/Interfaces/IBasketViewModelService.cs b/src/Web/Interfaces/IBasketViewModelService.cs
index d7042deaa..ff45c17f9 100644
--- a/src/Web/Interfaces/IBasketViewModelService.cs
+++ b/src/Web/Interfaces/IBasketViewModelService.cs
@@ -5,7 +5,7 @@ namespace Microsoft.eShopWeb.Web.Interfaces;
 
 public interface IBasketViewModelService
 {
-    Task<BasketViewModel> GetOrCreateBasketForUser(string userName);
-    Task<int> CountTotalBasketItems(string username);
-    Task<BasketViewModel> Map(Basket basket);
+    Task<BasketViewModel> GetOrCreateBasketForUserAsync(string userName);
+    Task<int> CountTotalBasketItemsAsync(string username);
+    Task<BasketViewModel> MapAsync(Basket basket);
 }
diff --git a/src/Web/Interfaces/ICatalogItemViewModelService.cs b/src/Web/Interfaces/ICatalogItemViewModelService.cs
index ede5902e8..c2cbf216a 100644
--- a/src/Web/Interfaces/ICatalogItemViewModelService.cs
+++ b/src/Web/Interfaces/ICatalogItemViewModelService.cs
@@ -5,5 +5,5 @@ namespace Microsoft.eShopWeb.Web.Interfaces;
 
 public interface ICatalogItemViewModelService
 {
-    Task UpdateCatalogItem(CatalogItemViewModel viewModel);
+    Task UpdateCatalogItemAsync(CatalogItemViewModel viewModel);
 }
diff --git a/src/Web/Interfaces/ICatalogViewModelService.cs b/src/Web/Interfaces/ICatalogViewModelService.cs
index 338f83dfc..397aa85b0 100644
--- a/src/Web/Interfaces/ICatalogViewModelService.cs
+++ b/src/Web/Interfaces/ICatalogViewModelService.cs
@@ -7,7 +7,7 @@ namespace Microsoft.eShopWeb.Web.Services;
 
 public interface ICatalogViewModelService
 {
-    Task<CatalogIndexViewModel> GetCatalogItems(int pageIndex, int itemsPage, int? brandId, int? typeId);
-    Task<IEnumerable<SelectListItem>> GetBrands();
-    Task<IEnumerable<SelectListItem>> GetTypes();
+    Task<CatalogIndexViewModel> GetCatalogItemsAsync(int pageIndex, int itemsPage, int? brandId, int? typeId);
+    Task<IEnumerable<SelectListItem>> GetBrandsAsync();
+    Task<IEnumerable<SelectListItem>> GetTypesAsync();
 }
diff --git a/src/Web/Pages/Admin/EditCatalogItem.cshtml.cs b/src/Web/Pages/Admin/EditCatalogItem.cshtml.cs
index 7cd25693b..011b1fa9c 100644
--- a/src/Web/Pages/Admin/EditCatalogItem.cshtml.cs
+++ b/src/Web/Pages/Admin/EditCatalogItem.cshtml.cs
@@ -30,7 +30,7 @@ public async Task<IActionResult> OnPostAsync()
     {
         if (ModelState.IsValid)
         {
-            await _catalogItemViewModelService.UpdateCatalogItem(CatalogModel);
+            await _catalogItemViewModelService.UpdateCatalogItemAsync(CatalogModel);
         }
 
         return RedirectToPage("/Admin/Index");
diff --git a/src/Web/Pages/Basket/Checkout.cshtml.cs b/src/Web/Pages/Basket/Checkout.cshtml.cs
index ee545927f..14dbc30b4 100644
--- a/src/Web/Pages/Basket/Checkout.cshtml.cs
+++ b/src/Web/Pages/Basket/Checkout.cshtml.cs
@@ -36,12 +36,12 @@ public CheckoutModel(IBasketService basketService,
 
     public BasketViewModel BasketModel { get; set; } = new BasketViewModel();
 
-    public async Task OnGet()
+    public async Task OnGetAsync()
     {
         await SetBasketModelAsync();
     }
 
-    public async Task<IActionResult> OnPost(IEnumerable<BasketItemViewModel> items)
+    public async Task<IActionResult> OnPostAsync(IEnumerable<BasketItemViewModel> items)
     {
         try
         {
@@ -53,7 +53,7 @@ public async Task<IActionResult> OnPost(IEnumerable<BasketItemViewModel> items)
             }
 
             var updateModel = items.ToDictionary(b => b.Id.ToString(), b => b.Quantity);
-            await _basketService.SetQuantities(BasketModel.Id, updateModel);
+            await _basketService.SetQuantitiesAsync(BasketModel.Id, updateModel);
             await _orderService.CreateOrderAsync(BasketModel.Id, new Address("123 Main St.", "Kent", "OH", "United States", "44240"));
             await _basketService.DeleteBasketAsync(BasketModel.Id);
         }
@@ -72,12 +72,12 @@ private async Task SetBasketModelAsync()
         Guard.Against.Null(User?.Identity?.Name, nameof(User.Identity.Name));
         if (_signInManager.IsSignedIn(HttpContext.User))
         {
-            BasketModel = await _basketViewModelService.GetOrCreateBasketForUser(User.Identity.Name);
+            BasketModel = await _basketViewModelService.GetOrCreateBasketForUserAsync(User.Identity.Name);
         }
         else
         {
             GetOrSetBasketCookieAndUserName();
-            BasketModel = await _basketViewModelService.GetOrCreateBasketForUser(_username!);
+            BasketModel = await _basketViewModelService.GetOrCreateBasketForUserAsync(_username!);
         }
     }
 
diff --git a/src/Web/Pages/Basket/Index.cshtml.cs b/src/Web/Pages/Basket/Index.cshtml.cs
index 11e7a69d8..f5ebc0d3a 100644
--- a/src/Web/Pages/Basket/Index.cshtml.cs
+++ b/src/Web/Pages/Basket/Index.cshtml.cs
@@ -25,12 +25,12 @@ public IndexModel(IBasketService basketService,
 
     public BasketViewModel BasketModel { get; set; } = new BasketViewModel();
 
-    public async Task OnGet()
+    public async Task OnGetAsync()
     {
-        BasketModel = await _basketViewModelService.GetOrCreateBasketForUser(GetOrSetBasketCookieAndUserName());
+        BasketModel = await _basketViewModelService.GetOrCreateBasketForUserAsync(GetOrSetBasketCookieAndUserName());
     }
 
-    public async Task<IActionResult> OnPost(CatalogItemViewModel productDetails)
+    public async Task<IActionResult> OnPostAsync(CatalogItemViewModel productDetails)
     {
         if (productDetails?.Id == null)
         {
@@ -44,25 +44,25 @@ public async Task<IActionResult> OnPost(CatalogItemViewModel productDetails)
         }
 
         var username = GetOrSetBasketCookieAndUserName();
-        var basket = await _basketService.AddItemToBasket(username,
+        var basket = await _basketService.AddItemToBasketAsync(username,
             productDetails.Id, item.Price);
 
-        BasketModel = await _basketViewModelService.Map(basket);
+        BasketModel = await _basketViewModelService.MapAsync(basket);
 
         return RedirectToPage();
     }
 
-    public async Task OnPostUpdate(IEnumerable<BasketItemViewModel> items)
+    public async Task OnPostUpdateAsync(IEnumerable<BasketItemViewModel> items)
     {
         if (!ModelState.IsValid)
         {
             return;
         }
 
-        var basketView = await _basketViewModelService.GetOrCreateBasketForUser(GetOrSetBasketCookieAndUserName());
+        var basketView = await _basketViewModelService.GetOrCreateBasketForUserAsync(GetOrSetBasketCookieAndUserName());
         var updateModel = items.ToDictionary(b => b.Id.ToString(), b => b.Quantity);
-        var basket = await _basketService.SetQuantities(basketView.Id, updateModel);
-        BasketModel = await _basketViewModelService.Map(basket);
+        var basket = await _basketService.SetQuantitiesAsync(basketView.Id, updateModel);
+        BasketModel = await _basketViewModelService.MapAsync(basket);
     }
 
     private string GetOrSetBasketCookieAndUserName()
diff --git a/src/Web/Pages/Index.cshtml.cs b/src/Web/Pages/Index.cshtml.cs
index ad6a81edd..a80f3fa4a 100644
--- a/src/Web/Pages/Index.cshtml.cs
+++ b/src/Web/Pages/Index.cshtml.cs
@@ -15,8 +15,8 @@ public IndexModel(ICatalogViewModelService catalogViewModelService)
 
     public required CatalogIndexViewModel CatalogModel { get; set; } = new CatalogIndexViewModel();
 
-    public async Task OnGet(CatalogIndexViewModel catalogModel, int? pageId)
+    public async Task OnGetAsync(CatalogIndexViewModel catalogModel, int? pageId)
     {
-        CatalogModel = await _catalogViewModelService.GetCatalogItems(pageId ?? 0, Constants.ITEMS_PER_PAGE, catalogModel.BrandFilterApplied, catalogModel.TypesFilterApplied);
+        CatalogModel = await _catalogViewModelService.GetCatalogItemsAsync(pageId ?? 0, Constants.ITEMS_PER_PAGE, catalogModel.BrandFilterApplied, catalogModel.TypesFilterApplied);
     }
 }
diff --git a/src/Web/Pages/Shared/Components/BasketComponent/Basket.cs b/src/Web/Pages/Shared/Components/BasketComponent/Basket.cs
index 986c7b8a5..f138200cd 100644
--- a/src/Web/Pages/Shared/Components/BasketComponent/Basket.cs
+++ b/src/Web/Pages/Shared/Components/BasketComponent/Basket.cs
@@ -25,24 +25,24 @@ public async Task<IViewComponentResult> InvokeAsync()
     {
         var vm = new BasketComponentViewModel
         {
-            ItemsCount = await CountTotalBasketItems()
+            ItemsCount = await CountTotalBasketItemsAsync()
         };
         return View(vm);
     }
 
-    private async Task<int> CountTotalBasketItems()
+    private async Task<int> CountTotalBasketItemsAsync()
     {
         if (_signInManager.IsSignedIn(HttpContext.User))
         {
             Guard.Against.Null(User?.Identity?.Name, nameof(User.Identity.Name));
-            return await _basketService.CountTotalBasketItems(User.Identity.Name);
+            return await _basketService.CountTotalBasketItemsAsync(User.Identity.Name);
         }
 
         string? anonymousId = GetAnnonymousIdFromCookie();
         if (anonymousId == null)
             return 0;
 
-        return await _basketService.CountTotalBasketItems(anonymousId);
+        return await _basketService.CountTotalBasketItemsAsync(anonymousId);
     }
 
     private string? GetAnnonymousIdFromCookie()
diff --git a/src/Web/Services/BasketViewModelService.cs b/src/Web/Services/BasketViewModelService.cs
index 658d5712c..fa5bea165 100644
--- a/src/Web/Services/BasketViewModelService.cs
+++ b/src/Web/Services/BasketViewModelService.cs
@@ -25,20 +25,20 @@ public BasketViewModelService(IRepository<Basket> basketRepository,
         _itemRepository = itemRepository;
     }
 
-    public async Task<BasketViewModel> GetOrCreateBasketForUser(string userName)
+    public async Task<BasketViewModel> GetOrCreateBasketForUserAsync(string userName)
     {
         var basketSpec = new BasketWithItemsSpecification(userName);
         var basket = (await _basketRepository.FirstOrDefaultAsync(basketSpec));
 
         if (basket == null)
         {
-            return await CreateBasketForUser(userName);
+            return await CreateBasketForUserAsync(userName);
         }
-        var viewModel = await Map(basket);
+        var viewModel = await MapAsync(basket);
         return viewModel;
     }
 
-    private async Task<BasketViewModel> CreateBasketForUser(string userId)
+    private async Task<BasketViewModel> CreateBasketForUserAsync(string userId)
     {
         var basket = new Basket(userId);
         await _basketRepository.AddAsync(basket);
@@ -50,7 +50,7 @@ private async Task<BasketViewModel> CreateBasketForUser(string userId)
         };
     }
 
-    private async Task<List<BasketItemViewModel>> GetBasketItems(IReadOnlyCollection<BasketItem> basketItems)
+    private async Task<List<BasketItemViewModel>> GetBasketItemsAsync(IReadOnlyCollection<BasketItem> basketItems)
     {
         var catalogItemsSpecification = new CatalogItemsSpecification(basketItems.Select(b => b.CatalogItemId).ToArray());
         var catalogItems = await _itemRepository.ListAsync(catalogItemsSpecification);
@@ -74,19 +74,19 @@ private async Task<List<BasketItemViewModel>> GetBasketItems(IReadOnlyCollection
         return items;
     }
 
-    public async Task<BasketViewModel> Map(Basket basket)
+    public async Task<BasketViewModel> MapAsync(Basket basket)
     {
         return new BasketViewModel()
         {
             BuyerId = basket.BuyerId,
             Id = basket.Id,
-            Items = await GetBasketItems(basket.Items)
+            Items = await GetBasketItemsAsync(basket.Items)
         };
     }
 
-    public async Task<int> CountTotalBasketItems(string username)
+    public async Task<int> CountTotalBasketItemsAsync(string username)
     {
-        var counter = await _basketQueryService.CountTotalBasketItems(username);
+        var counter = await _basketQueryService.CountTotalBasketItemsAsync(username);
 
         return counter;
     }
diff --git a/src/Web/Services/CachedCatalogViewModelService.cs b/src/Web/Services/CachedCatalogViewModelService.cs
index e7a506b45..81fcb56a2 100644
--- a/src/Web/Services/CachedCatalogViewModelService.cs
+++ b/src/Web/Services/CachedCatalogViewModelService.cs
@@ -19,32 +19,32 @@ public CachedCatalogViewModelService(IMemoryCache cache,
         _catalogViewModelService = catalogViewModelService;
     }
 
-    public async Task<IEnumerable<SelectListItem>> GetBrands()
+    public async Task<IEnumerable<SelectListItem>> GetBrandsAsync()
     {
         return (await _cache.GetOrCreateAsync(CacheHelpers.GenerateBrandsCacheKey(), async entry =>
                 {
                     entry.SlidingExpiration = CacheHelpers.DefaultCacheDuration;
-                    return await _catalogViewModelService.GetBrands();
+                    return await _catalogViewModelService.GetBrandsAsync();
                 })) ?? new List<SelectListItem>();
     }
 
-    public async Task<CatalogIndexViewModel> GetCatalogItems(int pageIndex, int itemsPage, int? brandId, int? typeId)
+    public async Task<CatalogIndexViewModel> GetCatalogItemsAsync(int pageIndex, int itemsPage, int? brandId, int? typeId)
     {
         var cacheKey = CacheHelpers.GenerateCatalogItemCacheKey(pageIndex, Constants.ITEMS_PER_PAGE, brandId, typeId);
 
         return (await _cache.GetOrCreateAsync(cacheKey, async entry =>
         {
             entry.SlidingExpiration = CacheHelpers.DefaultCacheDuration;
-            return await _catalogViewModelService.GetCatalogItems(pageIndex, itemsPage, brandId, typeId);
+            return await _catalogViewModelService.GetCatalogItemsAsync(pageIndex, itemsPage, brandId, typeId);
         })) ?? new CatalogIndexViewModel();
     }
 
-    public async Task<IEnumerable<SelectListItem>> GetTypes()
+    public async Task<IEnumerable<SelectListItem>> GetTypesAsync()
     {
         return (await _cache.GetOrCreateAsync(CacheHelpers.GenerateTypesCacheKey(), async entry =>
         {
             entry.SlidingExpiration = CacheHelpers.DefaultCacheDuration;
-            return await _catalogViewModelService.GetTypes();
+            return await _catalogViewModelService.GetTypesAsync();
         })) ?? new List<SelectListItem>();
     }
 }
diff --git a/src/Web/Services/CatalogItemViewModelService.cs b/src/Web/Services/CatalogItemViewModelService.cs
index 4b63ad09d..0d7fae000 100644
--- a/src/Web/Services/CatalogItemViewModelService.cs
+++ b/src/Web/Services/CatalogItemViewModelService.cs
@@ -15,7 +15,7 @@ public CatalogItemViewModelService(IRepository<CatalogItem> catalogItemRepositor
         _catalogItemRepository = catalogItemRepository;
     }
 
-    public async Task UpdateCatalogItem(CatalogItemViewModel viewModel)
+    public async Task UpdateCatalogItemAsync(CatalogItemViewModel viewModel)
     {
         var existingCatalogItem = await _catalogItemRepository.GetByIdAsync(viewModel.Id);
 
diff --git a/src/Web/Services/CatalogViewModelService.cs b/src/Web/Services/CatalogViewModelService.cs
index 4b1b21660..b5f6413ed 100644
--- a/src/Web/Services/CatalogViewModelService.cs
+++ b/src/Web/Services/CatalogViewModelService.cs
@@ -37,7 +37,7 @@ public CatalogViewModelService(
         _uriComposer = uriComposer;
     }
 
-    public async Task<CatalogIndexViewModel> GetCatalogItems(int pageIndex, int itemsPage, int? brandId, int? typeId)
+    public async Task<CatalogIndexViewModel> GetCatalogItemsAsync(int pageIndex, int itemsPage, int? brandId, int? typeId)
     {
         _logger.LogInformation("GetCatalogItems called.");
 
@@ -58,8 +58,8 @@ public async Task<CatalogIndexViewModel> GetCatalogItems(int pageIndex, int item
                 PictureUri = _uriComposer.ComposePicUri(i.PictureUri),
                 Price = i.Price
             }).ToList(),
-            Brands = (await GetBrands()).ToList(),
-            Types = (await GetTypes()).ToList(),
+            Brands = (await GetBrandsAsync()).ToList(),
+            Types = (await GetTypesAsync()).ToList(),
             BrandFilterApplied = brandId ?? 0,
             TypesFilterApplied = typeId ?? 0,
             PaginationInfo = new PaginationInfoViewModel()
@@ -77,7 +77,7 @@ public async Task<CatalogIndexViewModel> GetCatalogItems(int pageIndex, int item
         return vm;
     }
 
-    public async Task<IEnumerable<SelectListItem>> GetBrands()
+    public async Task<IEnumerable<SelectListItem>> GetBrandsAsync()
     {
         _logger.LogInformation("GetBrands called.");
         var brands = await _brandRepository.ListAsync();
@@ -93,7 +93,7 @@ public async Task<IEnumerable<SelectListItem>> GetBrands()
         return items;
     }
 
-    public async Task<IEnumerable<SelectListItem>> GetTypes()
+    public async Task<IEnumerable<SelectListItem>> GetTypesAsync()
     {
         _logger.LogInformation("GetTypes called.");
         var types = await _typeRepository.ListAsync();
diff --git a/tests/FunctionalTests/Web/Controllers/AccountControllerSignIn.cs b/tests/FunctionalTests/Web/Controllers/AccountControllerSignIn.cs
index 3375c94be..e9b25214d 100644
--- a/tests/FunctionalTests/Web/Controllers/AccountControllerSignIn.cs
+++ b/tests/FunctionalTests/Web/Controllers/AccountControllerSignIn.cs
@@ -19,7 +19,7 @@ public AccountControllerSignIn(TestApplication factory)
     public HttpClient Client { get; }
 
     [Fact]
-    public async Task ReturnsSignInScreenOnGet()
+    public async Task ReturnsSignInScreenOnGetAsync()
     {
         var response = await Client.GetAsync("/identity/account/login");
         response.EnsureSuccessStatusCode();
@@ -43,7 +43,7 @@ public void RegexMatchesValidRequestVerificationToken()
     }
 
     [Fact]
-    public async Task ReturnsFormWithRequestVerificationToken()
+    public async Task ReturnsFormWithRequestVerificationTokenAsync()
     {
         var response = await Client.GetAsync("/identity/account/login");
         response.EnsureSuccessStatusCode();
@@ -54,7 +54,7 @@ public async Task ReturnsFormWithRequestVerificationToken()
     }
 
     [Fact]
-    public async Task ReturnsSuccessfulSignInOnPostWithValidCredentials()
+    public async Task ReturnsSuccessfulSignInOnPostWithValidCredentialsAsync()
     {
         var getResponse = await Client.GetAsync("/identity/account/login");
         getResponse.EnsureSuccessStatusCode();
@@ -74,7 +74,7 @@ public async Task ReturnsSuccessfulSignInOnPostWithValidCredentials()
     }
 
     [Fact]
-    public async Task UpdatePhoneNumberProfile()
+    public async Task UpdatePhoneNumberProfileAsync()
     {
         //Login
         var getResponse = await Client.GetAsync("/identity/account/login");
diff --git a/tests/FunctionalTests/Web/Controllers/CatalogControllerIndex.cs b/tests/FunctionalTests/Web/Controllers/CatalogControllerIndex.cs
index 82c804b5c..db64b3921 100644
--- a/tests/FunctionalTests/Web/Controllers/CatalogControllerIndex.cs
+++ b/tests/FunctionalTests/Web/Controllers/CatalogControllerIndex.cs
@@ -15,7 +15,7 @@ public CatalogControllerIndex(TestApplication factory)
     public HttpClient Client { get; }
 
     [Fact]
-    public async Task ReturnsHomePageWithProductListing()
+    public async Task ReturnsHomePageWithProductListingAsync()
     {
         // Arrange & Act
         var response = await Client.GetAsync("/");
diff --git a/tests/FunctionalTests/Web/Controllers/OrderControllerIndex.cs b/tests/FunctionalTests/Web/Controllers/OrderControllerIndex.cs
index 88b37bf1c..6cacd790b 100644
--- a/tests/FunctionalTests/Web/Controllers/OrderControllerIndex.cs
+++ b/tests/FunctionalTests/Web/Controllers/OrderControllerIndex.cs
@@ -20,7 +20,7 @@ public OrderIndexOnGet(TestApplication factory)
     public HttpClient Client { get; }
 
     [Fact]
-    public async Task ReturnsRedirectGivenAnonymousUser()
+    public async Task ReturnsRedirectGivenAnonymousUserAsync()
     {
         var response = await Client.GetAsync("/order/my-orders");
         var redirectLocation = response!.Headers.Location!.OriginalString;
diff --git a/tests/FunctionalTests/Web/Pages/Basket/BasketPageCheckout.cs b/tests/FunctionalTests/Web/Pages/Basket/BasketPageCheckout.cs
index be2dbb0c4..161f1fd41 100644
--- a/tests/FunctionalTests/Web/Pages/Basket/BasketPageCheckout.cs
+++ b/tests/FunctionalTests/Web/Pages/Basket/BasketPageCheckout.cs
@@ -17,7 +17,7 @@ public BasketPageCheckout(TestApplication factory)
     public HttpClient Client { get; }
 
     [Fact]
-    public async Task RedirectsToLoginIfNotAuthenticated()
+    public async Task RedirectsToLoginIfNotAuthenticatedAsync()
     {
 
         // Load Home Page
diff --git a/tests/FunctionalTests/Web/Pages/Basket/CheckoutTest.cs b/tests/FunctionalTests/Web/Pages/Basket/CheckoutTest.cs
index 8d6c0be11..6062046e0 100644
--- a/tests/FunctionalTests/Web/Pages/Basket/CheckoutTest.cs
+++ b/tests/FunctionalTests/Web/Pages/Basket/CheckoutTest.cs
@@ -17,7 +17,7 @@ public CheckoutTest(TestApplication factory)
     public HttpClient Client { get; }
 
     [Fact]
-    public async Task SucessfullyPay()
+    public async Task SucessfullyPayAsync()
     {
 
         // Load Home Page
diff --git a/tests/FunctionalTests/Web/Pages/Basket/IndexTest.cs b/tests/FunctionalTests/Web/Pages/Basket/IndexTest.cs
index 1f68da7e1..e5bda321a 100644
--- a/tests/FunctionalTests/Web/Pages/Basket/IndexTest.cs
+++ b/tests/FunctionalTests/Web/Pages/Basket/IndexTest.cs
@@ -18,7 +18,7 @@ public IndexTest(TestApplication factory)
 
 
     [Fact]
-    public async Task OnPostUpdateTo50Successfully()
+    public async Task OnPostUpdateTo50SuccessfullyAsync()
     {
         // Load Home Page
         var response = await Client.GetAsync("/");
@@ -58,7 +58,7 @@ public async Task OnPostUpdateTo50Successfully()
     }
 
     [Fact]
-    public async Task OnPostUpdateTo0EmptyBasket()
+    public async Task OnPostUpdateTo0EmptyBasketAsync()
     {
         // Load Home Page
         var response = await Client.GetAsync("/");
diff --git a/tests/FunctionalTests/Web/Pages/HomePageOnGet.cs b/tests/FunctionalTests/Web/Pages/HomePageOnGet.cs
index 635d87b1e..d4edcfb55 100644
--- a/tests/FunctionalTests/Web/Pages/HomePageOnGet.cs
+++ b/tests/FunctionalTests/Web/Pages/HomePageOnGet.cs
@@ -14,7 +14,7 @@ public HomePageOnGet(TestApplication factory)
     public HttpClient Client { get; }
 
     [Fact]
-    public async Task ReturnsHomePageWithProductListing()
+    public async Task ReturnsHomePageWithProductListingAsync()
     {
         // Arrange & Act
         var response = await Client.GetAsync("/");
diff --git a/tests/IntegrationTests/Repositories/BasketRepositoryTests/SetQuantities.cs b/tests/IntegrationTests/Repositories/BasketRepositoryTests/SetQuantities.cs
index 95ba0e3e0..78a21c807 100644
--- a/tests/IntegrationTests/Repositories/BasketRepositoryTests/SetQuantities.cs
+++ b/tests/IntegrationTests/Repositories/BasketRepositoryTests/SetQuantities.cs
@@ -26,14 +26,14 @@ public SetQuantities()
     }
 
     [Fact]
-    public async Task RemoveEmptyQuantities()
+    public async Task RemoveEmptyQuantitiesAsync()
     {
         var basket = BasketBuilder.WithOneBasketItem();
         var basketService = new BasketService(_basketRepository, null);
         await _basketRepository.AddAsync(basket);
         _catalogContext.SaveChanges();
 
-        await basketService.SetQuantities(BasketBuilder.BasketId, new Dictionary<string, int>() { { BasketBuilder.BasketId.ToString(), 0 } });
+        await basketService.SetQuantitiesAsync(BasketBuilder.BasketId, new Dictionary<string, int>() { { BasketBuilder.BasketId.ToString(), 0 } });
 
         Assert.Equal(0, basket.Items.Count);
     }
diff --git a/tests/IntegrationTests/Repositories/OrderRepositoryTests/GetById.cs b/tests/IntegrationTests/Repositories/OrderRepositoryTests/GetById.cs
index cd1309c04..2602d7958 100644
--- a/tests/IntegrationTests/Repositories/OrderRepositoryTests/GetById.cs
+++ b/tests/IntegrationTests/Repositories/OrderRepositoryTests/GetById.cs
@@ -26,7 +26,7 @@ public GetById(ITestOutputHelper output)
     }
 
     [Fact]
-    public async Task GetsExistingOrder()
+    public async Task GetsExistingOrderAsync()
     {
         var existingOrder = OrderBuilder.WithDefaultValues();
         _catalogContext.Orders.Add(existingOrder);
diff --git a/tests/IntegrationTests/Repositories/OrderRepositoryTests/GetByIdWithItemsAsync.cs b/tests/IntegrationTests/Repositories/OrderRepositoryTests/GetByIdWithItemsAsync.cs
index 77e919009..e04138450 100644
--- a/tests/IntegrationTests/Repositories/OrderRepositoryTests/GetByIdWithItemsAsync.cs
+++ b/tests/IntegrationTests/Repositories/OrderRepositoryTests/GetByIdWithItemsAsync.cs
@@ -26,7 +26,7 @@ public GetByIdWithItemsAsync()
     }
 
     [Fact]
-    public async Task GetOrderAndItemsByOrderIdWhenMultipleOrdersPresent()
+    public async Task GetOrderAndItemsByOrderIdWhenMultipleOrdersPresentAsync()
     {
         //Arrange
         var itemOneUnitPrice = 5.50m;
diff --git a/tests/PublicApiIntegrationTests/AuthEndpoints/AuthenticateEndpointTest.cs b/tests/PublicApiIntegrationTests/AuthEndpoints/AuthenticateEndpointTest.cs
index 62550e6f4..a567a9359 100644
--- a/tests/PublicApiIntegrationTests/AuthEndpoints/AuthenticateEndpointTest.cs
+++ b/tests/PublicApiIntegrationTests/AuthEndpoints/AuthenticateEndpointTest.cs
@@ -16,7 +16,7 @@ public class AuthenticateEndpoint
     [DataRow("demouser@microsoft.com", AuthorizationConstants.DEFAULT_PASSWORD, true)]
     [DataRow("demouser@microsoft.com", "badpassword", false)]
     [DataRow("baduser@microsoft.com", "badpassword", false)]
-    public async Task ReturnsExpectedResultGivenCredentials(string testUsername, string testPassword, bool expectedResult)
+    public async Task ReturnsExpectedResultGivenCredentialsAsync(string testUsername, string testPassword, bool expectedResult)
     {
         var request = new AuthenticateRequest()
         {
diff --git a/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CatalogItemGetByIdEndpointTest.cs b/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CatalogItemGetByIdEndpointTest.cs
index 9baefdec7..f9bed509a 100644
--- a/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CatalogItemGetByIdEndpointTest.cs
+++ b/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CatalogItemGetByIdEndpointTest.cs
@@ -10,7 +10,7 @@ namespace PublicApiIntegrationTests.CatalogItemEndpoints;
 public class CatalogItemGetByIdEndpointTest
 {
     [TestMethod]
-    public async Task ReturnsItemGivenValidId()
+    public async Task ReturnsItemGivenValidIdAsync()
     {
         var response = await ProgramTest.NewClient.GetAsync("api/catalog-items/5");
         response.EnsureSuccessStatusCode();
@@ -22,7 +22,7 @@ public async Task ReturnsItemGivenValidId()
     }
 
     [TestMethod]
-    public async Task ReturnsNotFoundGivenInvalidId()
+    public async Task ReturnsNotFoundGivenInvalidIdAsync()
     {
         var response = await ProgramTest.NewClient.GetAsync("api/catalog-items/0");
 
diff --git a/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CatalogItemListPagedEndpoint.cs b/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CatalogItemListPagedEndpoint.cs
index 547011154..9ce02bdb3 100644
--- a/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CatalogItemListPagedEndpoint.cs
+++ b/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CatalogItemListPagedEndpoint.cs
@@ -14,7 +14,7 @@ namespace PublicApiIntegrationTests.CatalogItemEndpoints;
 public class CatalogItemListPagedEndpoint
 {
     [TestMethod]
-    public async Task ReturnsFirst10CatalogItems()
+    public async Task ReturnsFirst10CatalogItemsAsync()
     {
         var client = ProgramTest.NewClient;
         var response = await client.GetAsync("/api/catalog-items?pageSize=10");
@@ -26,7 +26,7 @@ public async Task ReturnsFirst10CatalogItems()
     }
 
     [TestMethod]
-    public async Task ReturnsCorrectCatalogItemsGivenPageIndex1()
+    public async Task ReturnsCorrectCatalogItemsGivenPageIndex1Async()
     {
 
         var pageSize = 10;
@@ -54,7 +54,7 @@ public async Task ReturnsCorrectCatalogItemsGivenPageIndex1()
     [DataRow("catalog-brands")]
     [DataRow("catalog-types")]
     [DataRow("catalog-items/1")]
-    public async Task SuccessFullMutipleParallelCall(string endpointName)
+    public async Task SuccessFullMutipleParallelCallAsync(string endpointName)
     {
         var client = ProgramTest.NewClient;
         var tasks = new List<Task<HttpResponseMessage>>();
diff --git a/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CreateCatalogItemEndpointTest.cs b/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CreateCatalogItemEndpointTest.cs
index 6c5d79e45..c4a77765a 100644
--- a/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CreateCatalogItemEndpointTest.cs
+++ b/tests/PublicApiIntegrationTests/CatalogItemEndpoints/CreateCatalogItemEndpointTest.cs
@@ -21,7 +21,7 @@ public class CreateCatalogItemEndpointTest
 
 
     [TestMethod]
-    public async Task ReturnsNotAuthorizedGivenNormalUserToken()
+    public async Task ReturnsNotAuthorizedGivenNormalUserTokenAsync()
     {
         var jsonContent = GetValidNewItemJson();
         var token = ApiTokenHelper.GetNormalUserToken();
@@ -33,7 +33,7 @@ public async Task ReturnsNotAuthorizedGivenNormalUserToken()
     }
 
     [TestMethod]
-    public async Task ReturnsSuccessGivenValidNewItemAndAdminUserToken()
+    public async Task ReturnsSuccessGivenValidNewItemAndAdminUserTokenAsync()
     {
         var jsonContent = GetValidNewItemJson();
         var adminToken = ApiTokenHelper.GetAdminUserToken();
diff --git a/tests/PublicApiIntegrationTests/CatalogItemEndpoints/DeleteCatalogItemEndpointTest.cs b/tests/PublicApiIntegrationTests/CatalogItemEndpoints/DeleteCatalogItemEndpointTest.cs
index 98c821238..0ba618605 100644
--- a/tests/PublicApiIntegrationTests/CatalogItemEndpoints/DeleteCatalogItemEndpointTest.cs
+++ b/tests/PublicApiIntegrationTests/CatalogItemEndpoints/DeleteCatalogItemEndpointTest.cs
@@ -11,7 +11,7 @@ namespace PublicApiIntegrationTests.CatalogItemEndpoints;
 public class DeleteCatalogItemEndpointTest
 {
     [TestMethod]
-    public async Task ReturnsSuccessGivenValidIdAndAdminUserToken()
+    public async Task ReturnsSuccessGivenValidIdAndAdminUserTokenAsync()
     {
         var adminToken = ApiTokenHelper.GetAdminUserToken();
         var client = ProgramTest.NewClient;
@@ -25,7 +25,7 @@ public async Task ReturnsSuccessGivenValidIdAndAdminUserToken()
     }
 
     [TestMethod]
-    public async Task ReturnsNotFoundGivenInvalidIdAndAdminUserToken()
+    public async Task ReturnsNotFoundGivenInvalidIdAndAdminUserTokenAsync()
     {
         var adminToken = ApiTokenHelper.GetAdminUserToken();
         var client = ProgramTest.NewClient;
diff --git a/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/AddItemToBasket.cs b/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/AddItemToBasket.cs
index 75e1744ef..6f799aed7 100644
--- a/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/AddItemToBasket.cs
+++ b/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/AddItemToBasket.cs
@@ -16,7 +16,7 @@ public class AddItemToBasket
     private readonly IAppLogger<BasketService> _mockLogger = Substitute.For<IAppLogger<BasketService>>();
 
     [Fact]
-    public async Task InvokesBasketRepositoryGetBySpecAsyncOnce()
+    public async Task InvokesBasketRepositoryGetBySpecOnceAsync()
     {
         var basket = new Basket(_buyerId);
         basket.AddItem(1, 1.5m);
@@ -25,13 +25,13 @@ public async Task InvokesBasketRepositoryGetBySpecAsyncOnce()
 
         var basketService = new BasketService(_mockBasketRepo, _mockLogger);
 
-        await basketService.AddItemToBasket(basket.BuyerId, 1, 1.50m);
+        await basketService.AddItemToBasketAsync(basket.BuyerId, 1, 1.50m);
 
         await _mockBasketRepo.Received().FirstOrDefaultAsync(Arg.Any<BasketWithItemsSpecification>(), default);
     }
 
     [Fact]
-    public async Task InvokesBasketRepositoryUpdateAsyncOnce()
+    public async Task InvokesBasketRepositoryUpdateOnceAsync()
     {
         var basket = new Basket(_buyerId);
         basket.AddItem(1, 1.1m, 1);
@@ -39,7 +39,7 @@ public async Task InvokesBasketRepositoryUpdateAsyncOnce()
 
         var basketService = new BasketService(_mockBasketRepo, _mockLogger);
 
-        await basketService.AddItemToBasket(basket.BuyerId, 1, 1.50m);
+        await basketService.AddItemToBasketAsync(basket.BuyerId, 1, 1.50m);
 
         await _mockBasketRepo.Received().UpdateAsync(basket, default);
     }
diff --git a/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/DeleteBasket.cs b/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/DeleteBasket.cs
index 0856d3d2a..8cb30ec3d 100644
--- a/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/DeleteBasket.cs
+++ b/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/DeleteBasket.cs
@@ -15,7 +15,7 @@ public class DeleteBasket
     private readonly IAppLogger<BasketService> _mockLogger = Substitute.For<IAppLogger<BasketService>>();
 
     [Fact]
-    public async Task ShouldInvokeBasketRepositoryDeleteAsyncOnce()
+    public async Task ShouldInvokeBasketRepositoryDeleteOnceAsync()
     {
         var basket = new Basket(_buyerId);
         basket.AddItem(1, 1.1m, 1);
diff --git a/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/TransferBasket.cs b/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/TransferBasket.cs
index a21afb319..c69d53e21 100644
--- a/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/TransferBasket.cs
+++ b/tests/UnitTests/ApplicationCore/Services/BasketServiceTests/TransferBasket.cs
@@ -32,7 +32,7 @@ public Results<T> Then(Func<T> value)
     }
 
         [Fact]
-    public async Task InvokesBasketRepositoryFirstOrDefaultAsyncOnceIfAnonymousBasketNotExists()
+    public async Task InvokesBasketRepositoryFirstOrDefaultAsyncOnceIfAnonymousBasketNotExistsAsync()
     {
             var anonymousBasket = null as Basket;
             var userBasket = new Basket(_existentUserBasketBuyerId);
@@ -48,7 +48,7 @@ public async Task InvokesBasketRepositoryFirstOrDefaultAsyncOnceIfAnonymousBaske
     }
 
     [Fact]
-    public async Task TransferAnonymousBasketItemsWhilePreservingExistingUserBasketItems()
+    public async Task TransferAnonymousBasketItemsWhilePreservingExistingUserBasketItemsAsync()
     {
         var anonymousBasket = new Basket(_existentAnonymousBasketBuyerId);
         anonymousBasket.AddItem(1, 10, 1);
@@ -72,7 +72,7 @@ public async Task TransferAnonymousBasketItemsWhilePreservingExistingUserBasketI
     }
 
     [Fact]
-    public async Task RemovesAnonymousBasketAfterUpdatingUserBasket()
+    public async Task RemovesAnonymousBasketAfterUpdatingUserBasketAsync()
     {
         var anonymousBasket = new Basket(_existentAnonymousBasketBuyerId);
         var userBasket = new Basket(_existentUserBasketBuyerId);
@@ -88,7 +88,7 @@ public async Task RemovesAnonymousBasketAfterUpdatingUserBasket()
     }
 
     [Fact]
-    public async Task CreatesNewUserBasketIfNotExists()
+    public async Task CreatesNewUserBasketIfNotExistsAsync()
     {
         var anonymousBasket = new Basket(_existentAnonymousBasketBuyerId);
         var userBasket = null as Basket;
diff --git a/tests/UnitTests/MediatorHandlers/OrdersTests/GetMyOrders.cs b/tests/UnitTests/MediatorHandlers/OrdersTests/GetMyOrders.cs
index ccb4129cf..b83ef9bda 100644
--- a/tests/UnitTests/MediatorHandlers/OrdersTests/GetMyOrders.cs
+++ b/tests/UnitTests/MediatorHandlers/OrdersTests/GetMyOrders.cs
@@ -24,7 +24,7 @@ public GetMyOrders()
     }
 
     [Fact]
-    public async Task NotReturnNullIfOrdersArePresIent()
+    public async Task NotReturnNullIfOrdersArePresIentAsync()
     {
         var request = new eShopWeb.Web.Features.MyOrders.GetMyOrders("SomeUserName");
 
diff --git a/tests/UnitTests/MediatorHandlers/OrdersTests/GetOrderDetails.cs b/tests/UnitTests/MediatorHandlers/OrdersTests/GetOrderDetails.cs
index 625de042b..f22a23cee 100644
--- a/tests/UnitTests/MediatorHandlers/OrdersTests/GetOrderDetails.cs
+++ b/tests/UnitTests/MediatorHandlers/OrdersTests/GetOrderDetails.cs
@@ -26,7 +26,7 @@ public GetOrderDetails()
     }
 
     [Fact]
-    public async Task NotBeNullIfOrderExists()
+    public async Task NotBeNullIfOrderExistsAsync()
     {
         var request = new eShopWeb.Web.Features.OrderDetails.GetOrderDetails("SomeUserName", 0);