Support and test coverage for use in partial trust / Signing assembly

Author: SteveWilkes

AgileMapper.Net40/AgileMapper.Net40.csproj

@@ -54,6 +54,7 @@
     <Compile Include="..\VersionInfo.cs">
       <Link>Properties\VersionInfo.cs</Link>
     </Compile>
+    <Compile Include="Properties\AssemblyInfo.Net40.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

AgileMapper.Net40/Properties/AssemblyInfo.Net40.cs

@@ -0,0 +1,4 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("AgileObjects.AgileMapper.UnitTests")]
+[assembly: InternalsVisibleTo("AgileObjects.AgileMapper.UnitTests.NonParallel")]

AgileMapper.UnitTests.Polyfills/project.json

@@ -1,10 +1,13 @@
 {
   "version": "0.5.0-*",
+
   "buildOptions": {
     "warningsAsErrors": true,
     "outputName": "AgileObjects.AgileMapper.UnitTests.Polyfills"
   },
+
   "testRunner": "xunit",
+
   "frameworks": {
     "netcoreapp1.0": {
       "dependencies": {

AgileMapper.UnitTests/AgileMapper.UnitTests.csproj

@@ -114,6 +114,7 @@
     <Compile Include="WhenFlatteningObjects.cs" />
     <Compile Include="WhenMappingFromDictionaries.cs" />
     <Compile Include="WhenMappingToConstructors.cs" />
+    <Compile Include="WhenUsingPartialTrust.cs" />
     <Compile Include="WhenViewingMappingPlans.cs" />
     <Compile Include="Reflection\WhenAccessingTypeInformation.cs" />
     <Compile Include="SimpleTypeConversion\WhenConvertingToDoubles.cs" />

AgileMapper.UnitTests/TestClasses/CustomerViewModel.cs

@@ -1,6 +1,6 @@
 namespace AgileObjects.AgileMapper.UnitTests.TestClasses
 {
-    internal class CustomerViewModel : PersonViewModel
+    public class CustomerViewModel : PersonViewModel
     {
         public double Discount
         {

AgileMapper.UnitTests/TestClasses/PublicField.cs

@@ -1,6 +1,6 @@
 namespace AgileObjects.AgileMapper.UnitTests.TestClasses
 {
-    internal class PublicField<T>
+    public class PublicField<T>
     {
         public T Value;
     }

AgileMapper.UnitTests/TestClasses/PublicProperty.cs

@@ -1,6 +1,6 @@
 namespace AgileObjects.AgileMapper.UnitTests.TestClasses
 {
-    internal class PublicProperty<T>
+    public class PublicProperty<T>
     {
         public T Value
         {

AgileMapper.UnitTests/WhenUsingPartialTrust.cs

@@ -0,0 +1,102 @@
+namespace AgileObjects.AgileMapper.UnitTests
+{
+    using System;
+    using System.Security;
+    using System.Security.Policy;
+    using TestClasses;
+    using Xunit;
+
+    public class WhenUsingPartialTrust
+    {
+        [Fact]
+        public void ShouldPerformASimpleMapping()
+        {
+            ExecuteInPartialTrust(helper =>
+            {
+                helper.TestSimpleMapping();
+            });
+        }
+
+        [Fact]
+        public void ShouldPerformAComplexMapping()
+        {
+            ExecuteInPartialTrust(helper =>
+            {
+                helper.TestComplexMapping();
+            });
+        }
+
+        [Fact]
+        public void ShouldPerformADerivedMapping()
+        {
+            ExecuteInPartialTrust(helper =>
+            {
+                helper.TestDerivedMapping();
+            });
+        }
+
+        private static void ExecuteInPartialTrust(Action<MappingHelper> testAction)
+        {
+            AppDomain partialTrustDomain = null;
+
+            try
+            {
+                var evidence = new Evidence();
+                evidence.AddHostEvidence(new Zone(SecurityZone.Internet));
+
+                var permissions = new NamedPermissionSet(
+                    "PartialTrust",
+                    SecurityManager.GetStandardSandbox(evidence));
+
+                partialTrustDomain = AppDomain.CreateDomain(
+                    "PartialTrust",
+                    evidence,
+                    new AppDomainSetup { ApplicationBase = "." },
+                    permissions);
+
+                var helperType = typeof(MappingHelper);
+
+                var helper = (MappingHelper)partialTrustDomain
+                    .CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName);
+
+                testAction.Invoke(helper);
+            }
+            finally
+            {
+                if (partialTrustDomain != null)
+                {
+                    AppDomain.Unload(partialTrustDomain);
+                }
+            }
+        }
+    }
+
+    public class MappingHelper : MarshalByRefObject
+    {
+        public void TestSimpleMapping()
+        {
+            var source = new PublicProperty<string> { Value = "I don't trust you..." };
+            var result = Mapper.Map(source).ToANew<PublicField<string>>();
+
+            Assert.Equal("I don't trust you...", result.Value);
+        }
+
+        public void TestComplexMapping()
+        {
+            var source = new Customer { Name = "Untrusted!", Discount = 0.2m };
+            var result = Mapper.Map(source).ToANew<CustomerViewModel>();
+
+            Assert.Equal("Untrusted!", result.Name);
+            Assert.Equal(0.2, result.Discount);
+        }
+
+        public void TestDerivedMapping()
+        {
+            Person source = new Customer { Name = "Untrusted Person :(", Discount = 0.1m };
+            var result = Mapper.Map(source).ToANew<CustomerViewModel>();
+
+            Assert.Equal("Untrusted Person :(", result.Name);
+            Assert.Equal(0.1, result.Discount);
+        }
+    }
+}

AgileMapper.snk

@@ -8,9 +8,17 @@
     using Extensions;
     using NetStandardPolyfills;
 
+    internal class TrustTester
+    {
+        // ReSharper disable once UnusedMember.Local
+        private static void IsPartialTrust() { }
+    }
+
     internal class DerivedTypesCache
     {
+        private static readonly bool _isPartialTrust;
         private static readonly Type[] _noTypes = { };
+
         private readonly ICache<Assembly, IEnumerable<Type>> _typesByAssembly;
         private readonly ICache<Type, ICollection<Type>> _derivedTypesByType;
 
@@ -20,6 +28,20 @@ public DerivedTypesCache()
             _derivedTypesByType = GlobalContext.Instance.Cache.CreateScoped<Type, ICollection<Type>>();
         }
 
+        static DerivedTypesCache()
+        {
+            try
+            {
+                typeof(TrustTester)
+                    .GetNonPublicStaticMethod("IsPartialTrust")
+                    .Invoke(null, null);
+            }
+            catch
+            {
+                _isPartialTrust = true;
+            }
+        }
+
         public ICollection<Type> GetTypesDerivedFrom(Type type)
         {
             if (type.IsSealed() || type.IsFromBcl())
@@ -54,7 +76,14 @@ private static IEnumerable<Type> GetTypesFromAssembly(Assembly assembly)
         {
             try
             {
-                return assembly.GetTypes();
+                IEnumerable<Type> types = assembly.GetTypes();
+
+                if (_isPartialTrust)
+                {
+                    types = types.Where(t => t.IsPublic());
+                }
+
+                return types;
             }
             catch (ReflectionTypeLoadException ex)
             {