GuidRaw16TypeHandlerTests.cs

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Reflection;
using Dapper.Oracle.TypeHandler;
using Dapper.Oracle.TypeMapping;
using FluentAssertions;
using Oracle.ManagedDataAccess.Client;
using Xunit;

namespace Tests.Dapper.Oracle.TypeHandlerTests
{
    public class GuidRaw16TypeHandlerTests
    {
        [Fact]
        public void ConvertTo()
        {
            Guid input = Guid.NewGuid();

            var parameter = new OracleParameter();
            var sut = new GuidRaw16TypeHandler();
            sut.SetValue(parameter,input);

            parameter.Value.Should().BeEquivalentTo(input.ToByteArray());
            parameter.OracleDbType.Should().Be(OracleDbType.Raw);
        }

        [Fact]
        public void ConvertFrom()
        {
            Guid input = Guid.NewGuid();

            var sut = new GuidRaw16TypeHandler();
            var result = sut.Parse(input.ToByteArray());
            result.Should().Be(input);
        }

        /// <summary>
        /// Verifies that TypeHandlerBase.OracleDbTypeProperty cache does not grow
        /// unboundedly when SetValue is called multiple times with the same parameter type.
        ///
        /// This test catches a bug in DictionaryKeyComparer.Equals where the condition
        /// "if (x != null && y != null) return false" caused every cache lookup to fail,
        /// resulting in unbounded cache growth and memory leaks.
        /// </summary>
        [Fact]
        public void SetValue_ShouldReuseCache_WhenCalledMultipleTimes()
        {
            var sut = new GuidRaw16TypeHandler();

            // Get the OracleDbTypeProperty cache via reflection
            var baseType = typeof(GuidRaw16TypeHandler).BaseType;
            var cacheField = baseType?.GetField("OracleDbTypeProperty",
                BindingFlags.NonPublic | BindingFlags.Static);

            cacheField.Should().NotBeNull("TypeHandlerBase should have OracleDbTypeProperty field");

            var cache = cacheField.GetValue(null) as ICollection;
            cache.Should().NotBeNull("OracleDbTypeProperty should be a collection");

            // Record initial cache count
            int initialCount = cache.Count;

            // Call SetValue multiple times with the same parameter type
            const int iterations = 100;
            for (int i = 0; i < iterations; i++)
            {
                var parameter = new OracleParameter();
                sut.SetValue(parameter, Guid.NewGuid());
            }

            // Cache should have grown by at most 1 entry (for the OracleParameter + "Raw" combination)
            int finalCount = cache.Count;
            int cacheGrowth = finalCount - initialCount;

            cacheGrowth.Should().BeLessOrEqualTo(1,
                $"cache should reuse entries for same parameter type, but grew by {cacheGrowth} entries after {iterations} calls. " +
                "This indicates a bug in DictionaryKeyComparer.Equals causing cache entries to never match.");
        }
    }
}