Split DirectoryOperationsTest into platform-specific test classes

- Created DirectoryOperationsWindowsTest for Windows-specific tests
- Created DirectoryOperationsUnixTest for Unix-specific tests
- Added RuntimeInformation platform check in Unix test setup
- Added [Platform(Exclude="Win")] to DirectoryUnixInformationTest
- Removed original mixed DirectoryOperationsTest file

This completes the platform-specific test refactoring to fix OneTimeSetUp
errors on Windows for net481 target framework.

Author: sfc-gh-mgemra

Snowflake.Data.Tests/UnitTests/Tools/DirectoryOperationsUnixTest.cs

@@ -0,0 +1,109 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using Mono.Unix;
+using Mono.Unix.Native;
+using NUnit.Framework;
+using Snowflake.Data.Core.Tools;
+using Snowflake.Data.Tests.Mock;
+
+namespace Snowflake.Data.Tests.UnitTests.Tools
+{
+    [TestFixture, NonParallelizable]
+    [Platform(Exclude = "Win")]
+    public class DirectoryOperationsUnixTest
+    {
+        private static DirectoryOperations s_directoryOperations;
+        private static readonly string s_relativeWorkingDirectory = $"directory_operations_test_{Path.GetRandomFileName()}";
+        private static readonly string s_workingDirectory = Path.Combine(TempUtil.GetTempPath(), s_relativeWorkingDirectory);
+        private static readonly string s_dirName = "testdir";
+        private static readonly string s_dirAbsolutePath = Path.Combine(s_workingDirectory, s_dirName);
+
+        [SetUp]
+        public static void Before()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Assert.Ignore("Unix-specific tests are not run on Windows");
+            }
+            
+            if (!Directory.Exists(s_workingDirectory))
+            {
+                Directory.CreateDirectory(s_workingDirectory);
+            }
+
+            s_directoryOperations = new DirectoryOperations();
+        }
+
+        [TearDown]
+        public static void After()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return;
+            }
+            
+            Directory.Delete(s_workingDirectory, true);
+        }
+
+        [Test]
+        public void TestDirectoryIsNotSafeOnNotWindowsWhenPermissionsAreTooBroad(
+            [ValueSource(nameof(InsecurePermissions))]
+            FileAccessPermissions permissions)
+        {
+            // arrange
+            Syscall.mkdir(s_dirAbsolutePath, (FilePermissions)permissions);
+
+            // act and assert
+            Assert.IsFalse(s_directoryOperations.IsDirectorySafe(s_dirAbsolutePath));
+        }
+
+        [Test]
+        public void TestOwnerIsCurrentUser()
+        {
+            // arrange
+            var mockUnixOperations = new MockUnixOperations { CurrentUserId = 1, DirectoryOwnerId = 1 };
+            var dirOps = new DirectoryOperations(mockUnixOperations);
+
+            // act and assert
+            Assert.IsTrue(dirOps.IsDirectoryOwnedByCurrentUser(s_dirAbsolutePath));
+        }
+
+        [Test]
+        public void TestOwnerIsNotCurrentUser()
+        {
+            // arrange
+            var mockUnixOperations = new MockUnixOperations { CurrentUserId = 1, DirectoryOwnerId = 2 };
+            var dirOps = new DirectoryOperations(mockUnixOperations);
+
+            // act and assert
+            Assert.IsFalse(dirOps.IsDirectoryOwnedByCurrentUser(s_dirAbsolutePath));
+        }
+
+        [Test]
+        public void TestDirectoryIsNotSecureWhenNotOwnedByCurrentUser()
+        {
+            // arrange
+            var mockUnixOperations = new MockUnixOperations { CurrentUserId = 1, DirectoryOwnerId = 2 };
+            var dirOps = new DirectoryOperations(mockUnixOperations);
+
+            // act and assert
+            Assert.IsFalse(dirOps.IsDirectorySafe(s_dirAbsolutePath));
+        }
+
+        // User permissions are required for all of the tests to be able to access directory information
+        public static IEnumerable<FileAccessPermissions> InsecurePermissions()
+        {
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.GroupRead;
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.GroupRead | FileAccessPermissions.GroupWrite;
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.GroupExecute;
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.GroupReadWriteExecute;
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.OtherRead;
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.OtherRead | FileAccessPermissions.OtherWrite;
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.OtherExecute;
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.OtherReadWriteExecute;
+            yield return FileAccessPermissions.UserReadWriteExecute | FileAccessPermissions.AllPermissions;
+        }
+    }
+}
+

Snowflake.Data.Tests/UnitTests/Tools/DirectoryOperationsWindowsTest.cs

@@ -0,0 +1,59 @@
+using System.IO;
+using NUnit.Framework;
+using Snowflake.Data.Core.Tools;
+
+namespace Snowflake.Data.Tests.UnitTests.Tools
+{
+    [TestFixture, NonParallelizable]
+    [Platform("Win")]
+    public class DirectoryOperationsWindowsTest
+    {
+        private static DirectoryOperations s_directoryOperations;
+        private static readonly string s_relativeWorkingDirectory = $"directory_operations_test_{Path.GetRandomFileName()}";
+        private static readonly string s_workingDirectory = Path.Combine(TempUtil.GetTempPath(), s_relativeWorkingDirectory);
+        private static readonly string s_dirName = "testdir";
+
+        [SetUp]
+        public static void Before()
+        {
+            if (!Directory.Exists(s_workingDirectory))
+            {
+                Directory.CreateDirectory(s_workingDirectory);
+            }
+
+            s_directoryOperations = new DirectoryOperations();
+        }
+
+        [TearDown]
+        public static void After()
+        {
+            Directory.Delete(s_workingDirectory, true);
+        }
+
+        [Test]
+        public void TestDirectoryIsSafeOnWindows()
+        {
+            // arrange
+            var absoluteFilePath = Path.Combine(s_workingDirectory, s_dirName);
+            Directory.CreateDirectory(absoluteFilePath);
+
+            // act and assert
+            Assert.IsTrue(s_directoryOperations.IsDirectorySafe(absoluteFilePath));
+        }
+
+        [Test]
+        public void TestShouldCreateDirectoryWithSafePermissions()
+        {
+            // arrange
+            var dirAbsolutePath = Path.Combine(s_workingDirectory, s_dirName);
+
+            // act
+            s_directoryOperations.CreateDirectory(dirAbsolutePath);
+
+            // assert
+            Assert.IsTrue(Directory.Exists(dirAbsolutePath));
+            Assert.IsTrue(s_directoryOperations.IsDirectorySafe(dirAbsolutePath));
+        }
+    }
+}
+

Snowflake.Data.Tests/UnitTests/Tools/DirectoryUnixInformationTest.cs

@@ -6,6 +6,7 @@
 namespace Snowflake.Data.Tests.UnitTests.Tools
 {
     [TestFixture]
+    [Platform(Exclude = "Win")]
     public class DirectoryUnixInformationTest
     {
         private const long UserId = 5;