Completed azure data lake service mocking and started addeding unit tests

Author: MHD\nialan

DataPipelineTools.Tests/DataLake/DataLakeServiceTests.cs

@@ -24,11 +24,8 @@ public class DataLakeServiceTests: TestBase
         private const string ContainerName = "mycontainer";
 
         private readonly IEnumerable<PathItem> TestData;
-        private readonly Mock<DataLakeFileSystemClient> mockFileSystemClient;
-
-        //private readonly Mock<DataLakeDirectoryClient> mockDirectoryClient;
-        //private readonly Mock<DataLakeFileClient> mockFileClient;
 
+        private readonly Mock<DataLakeFileSystemClient> mockFileSystemClient;
         private readonly Mock<ILogger<DataLakeServiceFactory>> mockLogger;
 
         private readonly DataLakeService Sut;
@@ -64,14 +61,14 @@ private Mock<DataLakeFileSystemClient> BuildMockDataLakeFileSystemClient()
 
             mockFileSystemClient
                 .Setup(x => x.GetPaths(It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<CancellationToken>()))
-                .Returns((string p, bool r) =>
+                .Returns((string path, bool recursive, bool userPrinciaplName, CancellationToken token) =>
                 {
                     var items = TestData
                         // Include all files starting with the test path
-                        .Where(x => x.Name.StartsWith(p))
+                        .Where(x => x.Name.StartsWith(path ?? string.Empty) && path != null)
                         // Still include them if the recursive flag is set, otherwise check if the relative path after the search path contains 
                         // directory separator to exclude sub dirs
-                        .Where(x => r || !x.Name.Substring(p.Length).Contains('/'))
+                        .Where(x => recursive || !x.Name.Substring(path.Length).Contains('/'))
                         .ToList()
                         .AsReadOnly();
 
@@ -117,21 +114,7 @@ private IEnumerable<PathItem> GetTestData()
                     );
             }).ToArray();
         }
-
-//private IEnumerable<DataLakeItem> GetTestData()
-//        { 
-//            return GetTestData(",", properties =>
-//            {
-//                return new DataLakeItem()
-//                {
-//                    Directory = properties[nameof(DataLakeItem.Directory)],
-//                    Name = properties[nameof(DataLakeItem.Name)],
-//                    IsDirectory = Convert.ToBoolean(properties[nameof(DataLakeItem.IsDirectory)]),
-//                    ContentLength = Convert.ToInt32(properties[nameof(DataLakeItem.ContentLength)]),
-//                    LastModified = Convert.ToDateTime(properties[nameof(DataLakeItem.LastModified)])
-//                };
-//            }).ToArray();
-//        }
+        
 
         [SetUp]
         public void Setup()
@@ -140,11 +123,50 @@ public void Setup()
         }
 
         [Test]
-        public void CheckPathAsync_ShouldReturn_()
+        public void CheckPathAsync_ShouldReturnThePath_WhenTheDirectoryPathExists()
         {
+            var testPath = "raw/database";
+            var correctPath = Sut.CheckPathAsync(testPath, true).Result;
 
+            Assert.That(testPath, Is.EqualTo(correctPath));
         }
-
 
+        [Test]
+        public void CheckPathAsync_ShouldReturnThePath_WhenTheFilePathExists()
+        {
+            var testPath = "raw/database/jan/extract_1.csv";
+            var correctPath = Sut.CheckPathAsync(testPath, false).Result;
+
+            Assert.That(testPath, Is.EqualTo(correctPath));
+        }
+
+        [Test]
+        public void CheckPathAsync_ShouldReturnNull_WhenTheIsDirectoryIsIncorrectlyFalse()
+        {
+            var testPath = "raw/database";
+            var correctPath = Sut.CheckPathAsync(testPath, false).Result;
+
+            Assert.That(testPath, Is.EqualTo(correctPath));
+        }
+
+        [Test]
+        public void CheckPathAsync_ShouldReturnNull_WhenTheIsDirectoryIsIncorrectlyTrue()
+        {
+            var testPath = "raw/database/jan/extract_1.csv";
+            var correctPath = Sut.CheckPathAsync(testPath, true).Result;
+
+            Assert.That(testPath, Is.EqualTo(correctPath));
+        }
+
+        [Test]
+        public void CheckPathAsync_ShouldReturnNull_WhenPathDoesNotExist()
+        {
+            var testPath = "some/invalid/path";
+            var correctPath = Sut.CheckPathAsync(testPath, true).Result;
+
+            Assert.That(null, Is.EqualTo(correctPath));
+        }
+
+
     }
 }

DataPipelineTools.Tests/DataLake/DataLakeServiceTests_Data_DataLakeItem.csv renamed to DataPipelineTools.Tests/DataLake/DataLakeServiceTests_Data_PathItem.csv

@@ -18,10 +18,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <None Update="DataLake\DataLakeServiceTests_Data_DataLakeItem - Copy.csv">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DataLake\DataLakeServiceTests_Data_DataLakeItem.csv">
+    <None Update="DataLake\DataLakeServiceTests_Data_PathItem.csv">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
   </ItemGroup>