Heedls 441 edit course content

DigitalLearningSolutions.Data.Tests/DataServices/ProgressDataServiceTests.cs

@@ -160,5 +160,66 @@ public void CreateNewAspProgressRecord_adds_new_record()
                 transaction.Dispose();
             }
         }
+
+        [Test]
+        public void InsertNewAspProgressRecordsForTutorialIfNoneExist_inserts_new_records()
+        {
+            // Given
+            const int tutorialId = 12732;
+            const int customisationId = 14019;
+
+            using var transaction = new TransactionScope();
+            try
+            {
+                // When
+                var initialProgressIdsOnAspProgressRecords = tutorialContentTestHelper
+                    .GetDistinctProgressIdsOnAspProgressRecordsFromTutorialId(tutorialId).ToList();
+                progressDataService.InsertNewAspProgressRecordsForTutorialIfNoneExist(tutorialId, customisationId);
+                var resultProgressIdsOnAspProgressRecords = tutorialContentTestHelper
+                    .GetDistinctProgressIdsOnAspProgressRecordsFromTutorialId(tutorialId).ToList();
+
+                // Then
+                using (new AssertionScope())
+                {
+                    initialProgressIdsOnAspProgressRecords.Count.Should().Be(3);
+                    resultProgressIdsOnAspProgressRecords.Count.Should().Be(6);
+                }
+            }
+            finally
+            {
+                transaction.Dispose();
+            }
+        }
+
+        [Test]
+        public void
+            InsertNewAspProgressRecordsForTutorialIfNoneExist_does_not_insert_new_records_when_they_already_exist()
+        {
+            // Given
+            const int tutorialId = 12925;
+            const int customisationId = 27816;
+
+            using var transaction = new TransactionScope();
+            try
+            {
+                // When
+                var initialAspProgressIds = tutorialContentTestHelper
+                    .GetAspProgressFromTutorialId(tutorialId).ToList();
+                progressDataService.InsertNewAspProgressRecordsForTutorialIfNoneExist(tutorialId, customisationId);
+                var resultAspProgressIds = tutorialContentTestHelper
+                    .GetAspProgressFromTutorialId(tutorialId).ToList();
+
+                // Then
+                using (new AssertionScope())
+                {
+                    initialAspProgressIds.Count.Should()
+                        .Be(resultAspProgressIds.Count);
+                }
+            }
+            finally
+            {
+                transaction.Dispose();
+            }
+        }
     }
 }

DigitalLearningSolutions.Data.Tests/DataServices/SectionContentDataServiceTests.cs

@@ -1359,5 +1359,20 @@ public void GetSectionsByApplication_should_have_correct_results()
                 result.First().Tutorials.Should().BeEmpty();
             }
         }
+
+        [Test]
+        public void GetSectionById_returns_expected_section()
+        {
+            // Given
+            const int sectionId = 1;
+            const string expectedName = "Mouse skills";
+
+            // When
+            var result = sectionContentDataService.GetSectionById(sectionId);
+
+            // Then
+            result?.SectionId.Should().Be(sectionId);
+            result?.SectionName.Should().Be(expectedName);
+        }
     }
 }

DigitalLearningSolutions.Data.Tests/DataServices/TutorialContentDataServiceTests/TutorialTests.cs

@@ -2,21 +2,21 @@
 {
     using System.Collections.Generic;
     using System.Linq;
+    using System.Transactions;
     using FluentAssertions;
     using FluentAssertions.Execution;
     using NUnit.Framework;
 
     internal partial class TutorialContentDataServiceTests
     {
+        private const int CustomisationId = 1379;
+        private const int SectionId = 74;
+
         [Test]
         public void GetTutorialsBySectionId_returns_tutorials_correctly()
         {
-            // Given
-            const int customisationId = 1379;
-            const int sectionId = 74;
-
             // When
-            var result = tutorialContentDataService.GetTutorialsBySectionId(sectionId, customisationId).ToList();
+            var result = tutorialContentDataService.GetTutorialsBySectionId(SectionId, CustomisationId).ToList();
 
             // Then
             using (new AssertionScope())
@@ -42,5 +42,76 @@ public void GetTutorialIdsByCourse_returns_correct_tutorials()
             // Then
             result.Should().BeEquivalentTo(expectedTutorials);
         }
+
+        [Test]
+        public void
+            UpdateOrInsertCustomisationTutorialStatuses_updates_both_statuses_on_existing_CustomisationTutorial()
+        {
+            // When
+            using var transaction = new TransactionScope();
+            try
+            {
+                tutorialContentDataService.UpdateOrInsertCustomisationTutorialStatuses(
+                    49,
+                    CustomisationId,
+                    false,
+                    false
+                );
+                var result = tutorialContentDataService.GetTutorialsBySectionId(SectionId, CustomisationId).ToList();
+
+                using (new AssertionScope())
+                {
+                    result.First().TutorialId.Should().Be(49);
+                    result.First().TutorialName.Should().Be("View documents");
+                    result.First().Status.Should().BeFalse();
+                    result.First().DiagStatus.Should().BeFalse();
+                }
+            }
+            finally
+            {
+                transaction.Dispose();
+            }
+        }
+
+        [Test]
+        public void UpdateOrInsertCustomisationTutorialStatuses_inserts_new_CustomisationTutorial_when_one_does_not_exist()
+        {
+            // Given
+            const int tutorialId = 12732;
+            const int customisationId = 14019;
+
+            // When
+            using var transaction = new TransactionScope();
+            try
+            {
+                var initialResult =
+                    tutorialContentTestHelper.GetCustomisationTutorialByTutorialIdAndCustomisationId(
+                        tutorialId,
+                        customisationId
+                    );
+                tutorialContentDataService.UpdateOrInsertCustomisationTutorialStatuses(
+                    tutorialId,
+                    customisationId,
+                    true,
+                    true
+                );
+                var result = tutorialContentTestHelper.GetCustomisationTutorialByTutorialIdAndCustomisationId(
+                    tutorialId,
+                    customisationId
+                );
+
+                using (new AssertionScope())
+                {
+                    initialResult.Should().BeNull();
+                    result.Should().NotBeNull();
+                    result?.Status.Should().BeTrue();
+                    result?.DiagStatus.Should().BeTrue();
+                }
+            }
+            finally
+            {
+                transaction.Dispose();
+            }
+        }
     }
 }

DigitalLearningSolutions.Data.Tests/Services/SectionServiceTests.cs

@@ -0,0 +1,106 @@
+namespace DigitalLearningSolutions.Data.Tests.Services
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using DigitalLearningSolutions.Data.DataServices;
+    using DigitalLearningSolutions.Data.Models;
+    using DigitalLearningSolutions.Data.Services;
+    using FakeItEasy;
+    using FluentAssertions;
+    using FluentAssertions.Execution;
+    using NUnit.Framework;
+
+    public class SectionServiceTests
+    {
+        private ISectionContentDataService sectionContentDataService = null!;
+        private ISectionService sectionService = null!;
+        private ITutorialContentDataService tutorialContentDataService = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            sectionContentDataService = A.Fake<ISectionContentDataService>();
+            tutorialContentDataService = A.Fake<ITutorialContentDataService>();
+
+            sectionService = new SectionService(
+                sectionContentDataService,
+                tutorialContentDataService
+            );
+        }
+
+        [Test]
+        public void GetSectionsAndTutorialsForCustomisation_returns_fully_populated_list()
+        {
+            // Given
+            var tutorialOne = new Tutorial(1, "Test", true, true);
+            var tutorialTwo = new Tutorial(2, "Case", false, false);
+            var tutorials = new List<Tutorial> { tutorialOne, tutorialTwo };
+            var sectionOne = new Section(1, "Section");
+            var sectionTwo = new Section(2, "Second Section");
+            A.CallTo(() => sectionContentDataService.GetSectionsByApplicationId(1))
+                .Returns(new List<Section> { sectionOne, sectionTwo });
+            A.CallTo(() => tutorialContentDataService.GetTutorialsBySectionId(A<int>._, 1))
+                .Returns(tutorials);
+
+            // When
+            var result = sectionService.GetSectionsAndTutorialsForCustomisation(1, 1).ToList();
+
+            // Then
+            using (new AssertionScope())
+            {
+                A.CallTo(() => tutorialContentDataService.GetTutorialsBySectionId(A<int>._, 1))
+                    .MustHaveHappenedTwiceExactly();
+                result.Count.Should().Be(2);
+                result.First().SectionId.Should().Be(1);
+                result.First().SectionName.Should().Be("Section");
+                result.First().Tutorials.Should().BeEquivalentTo(tutorials);
+            }
+        }
+
+        [Test]
+        public void GetSectionAndTutorialsBySectionIdForCustomisation_returns_fully_populated_Section()
+        {
+            // Given
+            var tutorialOne = new Tutorial(1, "Test", true, true);
+            var tutorialTwo = new Tutorial(2, "Case", false, false);
+            var tutorials = new List<Tutorial> { tutorialOne, tutorialTwo };
+            var section = new Section(1, "Section");
+            A.CallTo(() => sectionContentDataService.GetSectionById(1))
+                .Returns(section);
+            A.CallTo(() => tutorialContentDataService.GetTutorialsBySectionId(A<int>._, 1))
+                .Returns(tutorials);
+
+            // When
+            var result = sectionService.GetSectionAndTutorialsBySectionIdForCustomisation(1, 1);
+
+            // Then
+            using (new AssertionScope())
+            {
+                A.CallTo(() => tutorialContentDataService.GetTutorialsBySectionId(A<int>._, 1))
+                    .MustHaveHappenedOnceExactly();
+                result?.SectionId.Should().Be(1);
+                result?.SectionName.Should().Be("Section");
+                result?.Tutorials.Should().BeEquivalentTo(tutorials);
+            }
+        }
+
+        [Test]
+        public void GetSectionAndTutorialsBySectionIdForCustomisation_returns_null_if_section_not_found()
+        {
+            // Given
+            A.CallTo(() => sectionContentDataService.GetSectionById(1))
+                .Returns(null);
+
+            // When
+            var result = sectionService.GetSectionAndTutorialsBySectionIdForCustomisation(1, 1);
+
+            // Then
+            using (new AssertionScope())
+            {
+                result.Should().BeNull();
+                A.CallTo(() => tutorialContentDataService.GetTutorialsBySectionId(A<int>._, 1))
+                    .MustNotHaveHappened();
+            }
+        }
+    }
+}

DigitalLearningSolutions.Data.Tests/Services/TutorialServiceTests.cs

@@ -0,0 +1,68 @@
+namespace DigitalLearningSolutions.Data.Tests.Services
+{
+    using System.Collections.Generic;
+    using DigitalLearningSolutions.Data.DataServices;
+    using DigitalLearningSolutions.Data.Models;
+    using DigitalLearningSolutions.Data.Services;
+    using FakeItEasy;
+    using FluentAssertions.Execution;
+    using NUnit.Framework;
+
+    public class TutorialServiceTests
+    {
+        private IProgressDataService progressDataService = null!;
+        private ITutorialContentDataService tutorialContentDataService = null!;
+        private ITutorialService tutorialService = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            progressDataService = A.Fake<IProgressDataService>();
+            tutorialContentDataService = A.Fake<ITutorialContentDataService>();
+
+            tutorialService = new TutorialService(
+                tutorialContentDataService,
+                progressDataService
+            );
+        }
+
+        [Test]
+        public void UpdateTutorialsStatuses_calls_data_services_correct_number_of_times()
+        {
+            // Given
+            var tutorialOne = new Tutorial(1, "Test", true, true);
+            var tutorialTwo = new Tutorial(2, "Case", false, false);
+            var tutorials = new List<Tutorial> { tutorialOne, tutorialTwo };
+            A.CallTo(
+                    () => tutorialContentDataService.UpdateOrInsertCustomisationTutorialStatuses(
+                        A<int>._,
+                        A<int>._,
+                        A<bool>._,
+                        A<bool>._
+                    )
+                )
+                .DoesNothing();
+            A.CallTo(() => progressDataService.InsertNewAspProgressRecordsForTutorialIfNoneExist(A<int>._, A<int>._))
+                .DoesNothing();
+
+            // When
+            tutorialService.UpdateTutorialsStatuses(tutorials, 1);
+
+            // Then
+            using (new AssertionScope())
+            {
+                A.CallTo(
+                        () => tutorialContentDataService.UpdateOrInsertCustomisationTutorialStatuses(
+                            A<int>._,
+                            A<int>._,
+                            A<bool>._,
+                            A<bool>._
+                        )
+                    )
+                    .MustHaveHappened(2, Times.Exactly);
+                A.CallTo(() => progressDataService.InsertNewAspProgressRecordsForTutorialIfNoneExist(A<int>._, A<int>._))
+                    .MustHaveHappened(2, Times.Exactly);
+            }
+        }
+    }
+}