Add tests for PersistentProxyBuilder

Author: stakx

src/Castle.Core.Tests/DynamicProxy.Tests/PersistentProxyBuilderTestCase.cs

@@ -1,4 +1,4 @@
-// Copyright 2004-2021 Castle Project - http://www.castleproject.org/
+// Copyright 2004-2025 Castle Project - http://www.castleproject.org/
 // 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,14 +12,23 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if FEATURE_ASSEMBLYBUILDER_SAVE
-
 namespace Castle.DynamicProxy.Tests
 {
 	using System;
+	using System.Collections.Generic;
 	using System.IO;
+	using System.Linq;
+	using System.Reflection;
+#if NET9_0_OR_GREATER
+	using System.Runtime.Loader;
+#endif
+
+	using Castle.DynamicProxy.Tests.Interfaces;
+
 	using NUnit.Framework;
 
+#if NET462_OR_GREATER
+
 	[TestFixture]
 	public class PersistentProxyBuilderTestCase
 	{
@@ -44,6 +53,107 @@ public void PersistentProxyBuilder_SavesSignedFile()
 			Assert.IsTrue(path.EndsWith(ModuleScope.DEFAULT_FILE_NAME));
 		}
 	}
-}
 
-#endif
+#elif NET9_0_OR_GREATER
+
+	[TestFixture]
+	[FixtureLifeCycle(LifeCycle.InstancePerTestCase)]
+	public class PersistentProxyBuilderTestCase
+	{
+		// The above fixture life cycle gives each test its own fresh fixture, such that each test.
+		// starts with an empty `assemblyPaths` list. This is important for parallel test execution
+		// to work correctly.
+		private List<string> assemblyPaths = new();
+
+		[SetUp]
+		public void EnsureNoAssembliesSaved()
+		{
+			Assume.That(assemblyPaths, Is.Empty, "Test did not start with an empty assembly paths list.");
+		}
+
+		[TearDown]
+		public void DeleteSavedAssemblies()
+		{
+			foreach (var assemblyPath in assemblyPaths)
+			{
+				File.Delete(assemblyPath);
+			}
+		}
+
+		[Test]
+		public void SavesOneAssemblyPerProxiedType()
+		{
+
+			var builder = new PersistentProxyBuilder();
+			builder.AssemblySaved += assemblyPaths.Add;
+
+			var oneProxyType = builder.CreateInterfaceProxyTypeWithoutTarget(typeof(IOne), Type.EmptyTypes, ProxyGenerationOptions.Default);
+
+			Assert.AreEqual(1, assemblyPaths.Count);
+
+			var twoProxyType = builder.CreateInterfaceProxyTypeWithoutTarget(typeof(ITwo), Type.EmptyTypes, ProxyGenerationOptions.Default);
+
+			Assert.AreEqual(2, assemblyPaths.Count);
+
+			InspectAssemblies(assemblyPaths, assemblies =>
+			{
+				var oneAssembly = assemblies[0];
+				Assert.NotNull(oneAssembly.GetType(oneProxyType.FullName));
+				Assert.Null(oneAssembly.GetType(twoProxyType.FullName));
+
+				var twoAssembly = assemblies[1];
+				Assert.Null(twoAssembly.GetType(oneProxyType.FullName));
+				Assert.NotNull(twoAssembly.GetType(twoProxyType.FullName));
+			});
+		}
+
+		[Test]
+		public void TypeCacheWorks()
+		{
+			Assume.That(assemblyPaths, Is.Empty, "Test did not start with an empty assembly paths list.");
+
+			var builder = new PersistentProxyBuilder();
+			builder.AssemblySaved += assemblyPaths.Add;
+
+			var proxyType1 = builder.CreateClassProxyType(typeof(object), Type.EmptyTypes, ProxyGenerationOptions.Default);
+			var proxyType2 = builder.CreateClassProxyType(typeof(object), Type.EmptyTypes, ProxyGenerationOptions.Default);
+
+			Assert.AreEqual(1, assemblyPaths.Count);
+			Assert.AreSame(proxyType1, proxyType2);
+			Assert.AreSame(proxyType1.Assembly, proxyType2.Assembly);
+		}
+
+		private void InspectAssemblies(IEnumerable<string> assemblyPaths, Action<List<Assembly>> inspect)
+		{
+			var alcs = new List<AssemblyLoadContext>();
+			try
+			{
+				var assemblies = new List<Assembly>();
+				foreach (var assemblyPath in assemblyPaths)
+				{
+					// All assemblies have the same name, so they require their own load contexts.
+					var alc = new AssemblyLoadContext(null, isCollectible: true);
+					alcs.Add(alc);
+
+					// Not using `alc.LoadFromAssemblyPath` because that could lock the files,
+					// preventing their deletion during test tear-down.
+					using var assemblyByteStream = new MemoryStream(File.ReadAllBytes(assemblyPath));
+					var assembly = alc.LoadFromStream(assemblyByteStream);
+					assemblies.Add(assembly);
+				}
+
+				inspect(assemblies);
+			}
+			finally
+			{
+				foreach (var alc in alcs)
+				{
+					alc.Unload();
+				}
+			}
+		}
+	}
+
+#endif
+
+}

src/Castle.Core/DynamicProxy/PersistentIsolatedTypesModuleScope.cs

@@ -54,6 +54,9 @@ public PersistentIsolatedTypesModuleScope(bool savePhysicalAssemblies = true,
 			usingStrongNamedModule = false;
 		}
 
+		// for testing purposes
+		internal event Action<string>? AssemblySaved;
+
 		internal override AssemblyBuilder CreateAssembly(bool signStrongName)
 		{
 			var assemblyName = GetAssemblyName(signStrongName);
@@ -116,6 +119,8 @@ internal override Type BuildType(TypeBuilder typeBuilder)
 					stream.Seek(0, SeekOrigin.Begin);
 					stream.CopyTo(file);
 					file.Close();
+
+					AssemblySaved?.Invoke(assemblyPath);
 				}
 
 				stream.Seek(0, SeekOrigin.Begin);

src/Castle.Core/DynamicProxy/PersistentProxyBuilder.cs

@@ -14,6 +14,7 @@
 
 #nullable enable
 
+using System;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Castle.DynamicProxy
@@ -81,6 +82,21 @@ public PersistentProxyBuilder(string? outputDirectory = null)
 			: base(new PersistentIsolatedTypesModuleScope(savePhysicalAssemblies: true, outputDirectory))
 		{
 		}
+
+		// for testing purposes
+		internal event Action<string>? AssemblySaved
+		{
+			add
+			{
+				var moduleScope = (PersistentIsolatedTypesModuleScope)ModuleScope;
+				moduleScope.AssemblySaved += value;
+			}
+			remove
+			{
+				var moduleScope = (PersistentIsolatedTypesModuleScope)ModuleScope;
+				moduleScope.AssemblySaved -= value;
+			}
+		}
 	}
 
 #endif