added tests for helpers and init common lib

test/unit/CollectionDefinitions/CacheTestsCollectionDefinition.cs

@@ -0,0 +1,9 @@
+using Xunit;
+
+namespace CommonLibTest.CollectionDefinitions;
+
+/// <summary>
+/// Test that use cache cannot run in parallel, they can have flaky behavior
+/// </summary>
+[CollectionDefinition(nameof(CacheTestCollectionDefinition), DisableParallelization = true)]
+public class CacheTestCollectionDefinition{}

test/unit/CommonLibHelperTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Security.Principal;
 using System.Text;
 using System.Threading.Tasks;
 using SharpHoundCommonLib;
@@ -293,5 +294,82 @@ public async Task RetryOnException_SucceedsOnLastAttempt() {
 
             Assert.True(success);
         }
+
+        [Fact]
+        public void DomainNameToDistinguishedName_DotsBecomeDcComponents()
+        {
+            var result = Helpers.DomainNameToDistinguishedName("test.local");
+            Assert.Equal("DC=test,DC=local", result);
+        }
+
+        [Theory]
+        [InlineData("S-1-5-32-544", "\\01\\02\\00\\00\\00\\00\\00\\05\\20\\00\\00\\00\\20\\02\\00\\00")]
+        public void ConvertSidToHexSid_ValidSid_MatchesSecurityIdentifierBinaryForm(string sid, string expectedHexSid)
+        {
+            // Arrange & Act
+            var actual = Helpers.ConvertSidToHexSid(sid);
+
+            // Assert
+            Assert.Equal(expectedHexSid, actual);
+            return;
+
+            static string BuildExpectedHexSid(string sid)
+            {
+                var securityIdentifier = new SecurityIdentifier(sid);
+                var sidBytes = new byte[securityIdentifier.BinaryLength];
+                securityIdentifier.GetBinaryForm(sidBytes, 0);
+                return $"\\{BitConverter.ToString(sidBytes).Replace('-', '\\')}";
+            }
+        }
+
+        [Fact]
+        public void ConvertSidToHexSid_InvalidSid_Throws()
+        {
+            Assert.ThrowsAny<ArgumentException>(() => Helpers.ConvertSidToHexSid("NOT-A-SID"));
+        }
+
+        [Theory]
+        [InlineData("s-1-5-18")]
+        [InlineData("S-1-5-18")]
+        public void IsSidFiltered_FilteredWellKnownSidsCaseInsensitive_ReturnsTrue(string sid)
+        {
+            Assert.True(Helpers.IsSidFiltered(sid));
+        }
+
+        [Theory]
+        [InlineData("S-1-5-80-1234567890")]
+        [InlineData("S-1-5-82-1234567890")] 
+        [InlineData("S-1-5-90-0")]
+        [InlineData("S-1-5-96-0")]
+        public void IsSidFiltered_FilteredPrefixes_ReturnsTrue(string sid)
+        {
+            Assert.True(Helpers.IsSidFiltered(sid));
+        }
+
+        [Theory]
+        [InlineData("S-1-5-21-1234567890")]
+        [InlineData("S-1-5-21")]
+        public void IsSidFiltered_ReturnsFalse(string sid)
+        {
+            Assert.False(Helpers.IsSidFiltered(sid));
+        }
+
+        [Fact]
+        public void ConvertLdapTimeToLong_Null_ReturnsMinusOne()
+        {
+            Assert.Equal(-1, Helpers.ConvertLdapTimeToLong(null));
+        }
+
+        [Fact]
+        public void ConvertLdapTimeToLong_InvalidNumber_ThrowsFormatException()
+        {
+            Assert.Throws<FormatException>(() => Helpers.ConvertLdapTimeToLong("not-a-number"));
+        }
+
+        [Fact]
+        public void ConvertLdapTimeToLong_ValidNumber_Parses()
+        {
+            Assert.Equal(123456789L, Helpers.ConvertLdapTimeToLong("123456789"));
+        }
     }
 }

test/unit/CommonLibTests.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Reflection;
+using CommonLibTest.CollectionDefinitions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using SharpHoundCommonLib;
+using Xunit;
+
+namespace CommonLibTest;
+
+[Collection(nameof(CacheTestCollectionDefinition))]
+public class CommonLibTests
+{
+
+    public CommonLibTests()
+    {
+        ResetCommonLibState();
+    }
+
+    [Fact]
+    public void InitializeCommonLib_FirstCallWithoutCache_CreatesAndSetsCacheInstance()
+    {
+        // Arrange & Act
+        CommonLib.InitializeCommonLib();
+
+        // Assert
+        var cache = Cache.GetCacheInstance();
+        Assert.NotNull(cache);
+        Assert.NotNull(cache.IdToTypeCache);
+        Assert.NotNull(cache.ValueToIdCache);
+        Assert.NotNull(cache.GlobalCatalogCache);
+        Assert.NotNull(cache.MachineSidCache);
+        Assert.NotNull(cache.SIDToDomainCache);
+    }
+
+    [Fact]
+    public void InitializeCommonLib_UsesProvidedInstance()
+    {
+        // Arrange
+        var provided = Cache.CreateNewCache();
+
+        // Act
+        CommonLib.InitializeCommonLib(cache: provided);
+
+        // Assert
+        Assert.Same(provided, Cache.GetCacheInstance());
+    }
+
+    [Fact]
+    public void InitializeCommonLib_2Calls_LogsWarningAndDoesNotReplaceCache()
+    {
+        // Arrange
+        var cache1 = Cache.CreateNewCache();
+        CommonLib.InitializeCommonLib(cache: cache1);
+
+        var cache2 = Cache.CreateNewCache();
+        var logger = new Mock<ILogger>();
+
+        // Act
+        CommonLib.InitializeCommonLib(logger.Object, cache2);
+
+        // Assert
+        Assert.Same(cache1, Cache.GetCacheInstance()); // cache1 should be then one used since lib was already initialized
+
+        logger.Verify(x => x.Log(
+                LogLevel.Warning,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, _) =>
+                    v.ToString() != null &&
+                    v.ToString().Contains("already initialized", StringComparison.InvariantCultureIgnoreCase)),
+                It.IsAny<Exception>(),
+                It.IsAny<Func<It.IsAnyType, Exception, string>>()),
+            Times.Once());
+    }
+
+    private static void ResetCommonLibState()
+    {
+        // Reset CommonLib._initialized (private static)
+        var commonLibType = typeof(CommonLib);
+        var initializedField = commonLibType.GetField("_initialized",
+            BindingFlags.Static | BindingFlags.NonPublic);
+
+        if (initializedField == null)
+            throw new InvalidOperationException("CommonLib _initialized field not found");
+
+        initializedField.SetValue(null, false);
+
+        // Reset cache singleton so tests don't leak state into each other
+        Cache.SetCacheInstance(null);
+    }
+}