HEEDLS-585 Welcome emails - Filter

DigitalLearningSolutions.Web.Tests/Controllers/TrackingSystem/Delegates/EmailDelegatesControllerTests.cs

@@ -0,0 +1,127 @@
+namespace DigitalLearningSolutions.Web.Tests.Controllers.TrackingSystem.Delegates
+{
+    using DigitalLearningSolutions.Data.DataServices;
+    using DigitalLearningSolutions.Data.Services;
+    using DigitalLearningSolutions.Web.Controllers.TrackingSystem.Delegates;
+    using DigitalLearningSolutions.Web.Helpers;
+    using DigitalLearningSolutions.Web.Tests.ControllerHelpers;
+    using DigitalLearningSolutions.Web.ViewModels.TrackingSystem.Delegates.EmailDelegates;
+    using FakeItEasy;
+    using FluentAssertions;
+    using Microsoft.AspNetCore.Http;
+    using Microsoft.AspNetCore.Mvc;
+    using NUnit.Framework;
+
+    public class EmailDelegatesControllerTests
+    {
+        private CentreCustomPromptHelper centreCustomPromptsHelper = null!;
+        private EmailDelegatesController emailDelegatesController = null!;
+
+        private HttpRequest httpRequest = null!;
+        private HttpResponse httpResponse = null!;
+        private IJobGroupsDataService jobGroupsDataService = null!;
+        private IPasswordResetService passwordResetService = null!;
+        private IUserService userService = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            var centreCustomPromptsService = A.Fake<ICentreCustomPromptsService>();
+            centreCustomPromptsHelper = new CentreCustomPromptHelper(centreCustomPromptsService);
+            userService = A.Fake<IUserService>();
+            jobGroupsDataService = A.Fake<IJobGroupsDataService>();
+            passwordResetService = A.Fake<IPasswordResetService>();
+
+            httpRequest = A.Fake<HttpRequest>();
+            httpResponse = A.Fake<HttpResponse>();
+            const string cookieName = "EmailDelegateFilter";
+            const string cookieValue = "JobGroupId|JobGroupId|1";
+
+            emailDelegatesController = new EmailDelegatesController(
+                    centreCustomPromptsHelper,
+                    jobGroupsDataService,
+                    passwordResetService,
+                    userService
+                )
+                .WithMockHttpContext(httpRequest, cookieName, cookieValue, httpResponse)
+                .WithMockUser(true)
+                .WithMockServices()
+                .WithMockTempData();
+        }
+
+        [Test]
+        public void Index_with_no_query_parameters_uses_cookie_value_for_filterBy()
+        {
+            // When
+            var result = emailDelegatesController.Index();
+
+            // Then
+            result.As<ViewResult>().Model.As<EmailDelegatesViewModel>().FilterBy.Should()
+                .Be("JobGroupId|JobGroupId|1");
+        }
+
+        [Test]
+        public void Index_with_query_parameters_uses_query_parameter_value_for_filterBy()
+        {
+            // Given
+            const string filterBy = "JobGroupId|JobGroupId|2";
+            A.CallTo(() => httpRequest.Query.ContainsKey("filterBy")).Returns(true);
+
+            // When
+            var result = emailDelegatesController.Index(filterBy);
+
+            // Then
+            result.As<ViewResult>().Model.As<EmailDelegatesViewModel>().FilterBy.Should()
+                .Be(filterBy);
+        }
+
+        [Test]
+        public void Index_with_CLEAR_filterBy_query_parameter_removes_cookie()
+        {
+            // Given
+            const string filterBy = "CLEAR";
+
+            // When
+            var result = emailDelegatesController.Index(filterBy);
+
+            // Then
+            A.CallTo(() => httpResponse.Cookies.Delete("EmailDelegateFilter")).MustHaveHappened();
+            result.As<ViewResult>().Model.As<EmailDelegatesViewModel>().FilterBy.Should()
+                .BeNull();
+        }
+
+        [Test]
+        public void Index_with_null_filterBy_and_new_filter_query_parameter_adds_new_cookie_value()
+        {
+            // Given
+            const string? filterBy = null;
+            const string newFilterValue = "JobGroupId|JobGroupId|2";
+
+            // When
+            var result = emailDelegatesController.Index(filterBy, newFilterValue);
+
+            // Then
+            A.CallTo(() => httpResponse.Cookies.Append("EmailDelegateFilter", newFilterValue, A<CookieOptions>._))
+                .MustHaveHappened();
+            result.As<ViewResult>().Model.As<EmailDelegatesViewModel>().FilterBy.Should()
+                .Be(newFilterValue);
+        }
+
+        [Test]
+        public void Index_with_CLEAR_filterBy_and_new_filter_query_parameter_sets_new_cookie_value()
+        {
+            // Given
+            const string filterBy = "CLEAR";
+            const string newFilterValue = "JobGroupId|JobGroupId|2";
+
+            // When
+            var result = emailDelegatesController.Index(filterBy, newFilterValue);
+
+            // Then
+            A.CallTo(() => httpResponse.Cookies.Append("EmailDelegateFilter", newFilterValue, A<CookieOptions>._))
+                .MustHaveHappened();
+            result.As<ViewResult>().Model.As<EmailDelegatesViewModel>().FilterBy.Should()
+                .Be(newFilterValue);
+        }
+    }
+}

DigitalLearningSolutions.Web.Tests/Helpers/FilteringHelperTests.cs

@@ -3,16 +3,26 @@
     using System.Linq;
     using DigitalLearningSolutions.Web.Helpers;
     using DigitalLearningSolutions.Web.Tests.TestHelpers;
+    using FakeItEasy;
     using FluentAssertions;
+    using Microsoft.AspNetCore.Http;
     using NUnit.Framework;
 
     public class FilteringHelperTests
     {
         private const string FilterByAlphaBravoCharlie = "Group|Name|Alpha╡Group|Name|Bravo╡Group|Name|Charlie";
+        private const string CookieName = "TestFilterCookie";
         private static readonly SortableItem ItemA1 = new SortableItem("a", 1);
         private static readonly SortableItem ItemA3 = new SortableItem("a", 3);
         private static readonly SortableItem ItemB2 = new SortableItem("b", 2);
         private static readonly IQueryable<SortableItem> InputItems = new[] { ItemA1, ItemA3, ItemB2 }.AsQueryable();
+        private HttpRequest httpRequest = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            httpRequest = A.Fake<HttpRequest>();
+        }
 
         [Test]
         public void FilterItems_returns_expected_items_with_single_filter()
@@ -139,5 +149,60 @@ public void AddNewFilterToFilterBy_appends_new_filter_even_if_substring(string f
             // Then
             result.Should().Be($"{filterBy}╡{newFilterValue}");
         }
+
+        [Test]
+        public void GetFilterBy_with_no_parameters_returns_cookie_value()
+        {
+            // Given
+            const string CookieValue = "Cookie Value";
+            A.CallTo(() => httpRequest.Cookies.ContainsKey(CookieName)).Returns(true);
+            A.CallTo(() => httpRequest.Cookies[CookieName]).Returns(CookieValue);
+
+            // When
+            var result = FilteringHelper.GetFilterBy(null, null, httpRequest, CookieName);
+
+            // Then
+            result.Should().Be(CookieValue);
+        }
+
+        [Test]
+        public void GetFilterBy_with_no_parameters_and_no_cookies_returns_defaultFilterValue()
+        {
+            // When
+            var result = FilteringHelper.GetFilterBy(null, null, httpRequest, CookieName, "default-filter");
+
+            // Then
+            result.Should().Be("default-filter");
+        }
+
+        [Test]
+        public void GetFilterBy_with_CLEAR_filterBy_and_no_filterValue_returns_null()
+        {
+            // When
+            var result = FilteringHelper.GetFilterBy("CLEAR", null, httpRequest, CookieName);
+
+            // Then
+            result.Should().BeNull();
+        }
+
+        [Test]
+        public void GetFilterBy_with_CLEAR_filterBy_and_set_filterValue_returns_filterValue()
+        {
+            // When
+            var result = FilteringHelper.GetFilterBy("CLEAR", "filter-value", httpRequest, CookieName);
+
+            // Then
+            result.Should().Be("filter-value");
+        }
+
+        [Test]
+        public void GetFilterBy_with_filterBy_and_filterValue_returns_combined_filter_by()
+        {
+            // When
+            var result = FilteringHelper.GetFilterBy("filter-by", "filter-value", httpRequest, CookieName);
+
+            // Then
+            result.Should().Be("filter-by╡filter-value");
+        }
     }
 }

DigitalLearningSolutions.Web.Tests/ViewModels/TrackingSystem/Delegates/EmailDelegates/EmailDelegatesViewModelFilterOptionsTests.cs

@@ -0,0 +1,137 @@
+namespace DigitalLearningSolutions.Web.Tests.ViewModels.TrackingSystem.Delegates.EmailDelegates
+{
+    using System.Collections.Generic;
+    using DigitalLearningSolutions.Data.Models.CustomPrompts;
+    using DigitalLearningSolutions.Data.Tests.TestHelpers;
+    using DigitalLearningSolutions.Web.Helpers;
+    using DigitalLearningSolutions.Web.Models.Enums;
+    using DigitalLearningSolutions.Web.ViewModels.Common.SearchablePage;
+    using DigitalLearningSolutions.Web.ViewModels.TrackingSystem.Delegates.EmailDelegates;
+    using FluentAssertions;
+    using NUnit.Framework;
+
+    public class EmailDelegatesViewModelFilterOptionsTests
+    {
+        [Test]
+        public void GetEmailDelegatesFilterViewModels_should_return_correct_job_group_filter()
+        {
+            // Given
+            var (jobGroups, expectedFilter) = GetSampleJobGroupsAndFilter();
+
+            // When
+            var result =
+                EmailDelegatesViewModelFilterOptions.GetEmailDelegatesFilterViewModels(jobGroups, new List<CustomPrompt>());
+
+            // Then
+            result.Should().ContainEquivalentOf(expectedFilter);
+        }
+
+        [Test]
+        public void GetEmailDelegatesFilterViewModels_should_return_correct_custom_prompt_filters()
+        {
+            // Given
+            var (customPrompts, expectedFilters) = GetSampleCustomPromptsAndFilters();
+
+            // When
+            var result = EmailDelegatesViewModelFilterOptions.GetEmailDelegatesFilterViewModels(
+                new List<(int, string)>(),
+                customPrompts
+            );
+
+            // Then
+            expectedFilters.ForEach(expectedFilter => result.Should().ContainEquivalentOf(expectedFilter));
+        }
+
+        private (IEnumerable<(int id, string name)> jobGroups, FilterViewModel filter) GetSampleJobGroupsAndFilter()
+        {
+            var jobGroups = new List<(int id, string name)> { (1, "J 1"), (2, "J 2") };
+
+            var jobGroupOptions = new[]
+            {
+                new FilterOptionViewModel(
+                    "J 1",
+                    "JobGroupId" + FilteringHelper.Separator +
+                    "JobGroupId" + FilteringHelper.Separator + 1,
+                    FilterStatus.Default
+                ),
+                new FilterOptionViewModel(
+                    "J 2",
+                    "JobGroupId" + FilteringHelper.Separator +
+                    "JobGroupId" + FilteringHelper.Separator + 2,
+                    FilterStatus.Default
+                )
+            };
+            var jobGroupFilter = new FilterViewModel("JobGroupId", "Job Group", jobGroupOptions);
+
+            return (jobGroups, jobGroupFilter);
+        }
+
+        private (List<CustomPrompt> customPrompts, List<FilterViewModel> filters) GetSampleCustomPromptsAndFilters()
+        {
+            var customPrompt1 = CustomPromptsTestHelper.GetDefaultCustomPrompt(
+                1,
+                "First prompt",
+                "Clinical\r\nNon-Clinical"
+            );
+            var customPrompt3 = CustomPromptsTestHelper.GetDefaultCustomPrompt(3);
+            var customPrompt4 = CustomPromptsTestHelper.GetDefaultCustomPrompt(4, "Fourth prompt", "C 1\r\nC 2\r\nC 3");
+            var customPrompts = new List<CustomPrompt> { customPrompt1, customPrompt3, customPrompt4 };
+
+            var customPrompt1Options = new[]
+            {
+                new FilterOptionViewModel(
+                    "Clinical",
+                    "Answer1" + FilteringHelper.Separator +
+                    "Answer1" + FilteringHelper.Separator + "Clinical",
+                    FilterStatus.Default
+                ),
+                new FilterOptionViewModel(
+                    "Non-Clinical",
+                    "Answer1" + FilteringHelper.Separator +
+                    "Answer1" + FilteringHelper.Separator + "Non-Clinical",
+                    FilterStatus.Default
+                ),
+                new FilterOptionViewModel(
+                    "No option selected",
+                    "Answer1" + FilteringHelper.Separator +
+                    "Answer1" + FilteringHelper.Separator + FilteringHelper.EmptyValue,
+                    FilterStatus.Default
+                )
+            };
+            var customPrompt4Options = new[]
+            {
+                new FilterOptionViewModel(
+                    "C 1",
+                    "Answer4" + FilteringHelper.Separator +
+                    "Answer4" + FilteringHelper.Separator + "C 1",
+                    FilterStatus.Default
+                ),
+                new FilterOptionViewModel(
+                    "C 2",
+                    "Answer4" + FilteringHelper.Separator +
+                    "Answer4" + FilteringHelper.Separator + "C 2",
+                    FilterStatus.Default
+                ),
+                new FilterOptionViewModel(
+                    "C 3",
+                    "Answer4" + FilteringHelper.Separator +
+                    "Answer4" + FilteringHelper.Separator + "C 3",
+                    FilterStatus.Default
+                ),
+                new FilterOptionViewModel(
+                    "No option selected",
+                    "Answer4" + FilteringHelper.Separator +
+                    "Answer4" + FilteringHelper.Separator + FilteringHelper.EmptyValue,
+                    FilterStatus.Default
+                )
+            };
+            var customPromptFilters = new List<FilterViewModel>
+            {
+                new FilterViewModel("CustomPrompt1", "First prompt", customPrompt1Options),
+                new FilterViewModel("CustomPrompt4", "Fourth prompt", customPrompt4Options)
+            };
+
+            return (customPrompts, customPromptFilters);
+        }
+    }
+}