Fix version tolerance when bad assembly version specified in type manifest (#149)

* Added red test

* Ignore assembly version, if specified

* Handling assembly loading failure

* Fix mscorelib substitution case

* Fixed ToQualifiedAssemblyName test

* Strip assembly version with regex

* Reuse existing assembly version strip regex

Author: IgorFedchenko

src/Hyperion.Tests/Bugs.cs

@@ -11,6 +11,11 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Text;
+using FluentAssertions;
+using Hyperion.Extensions;
 using Xunit;
 
 namespace Hyperion.Tests
@@ -85,6 +90,69 @@ public void CanSerializeMessageWithByte()
             var res = serializer.Deserialize(stream);
         }
 
+        /// <summary>
+        /// Fix for https://github.com/akkadotnet/Hyperion/issues/144
+        /// </summary>
+        [Fact]
+        public void CanFindTypeByManifest_WhenManifestContainsUnknownAssemblyVersion()
+        {
+            var serializer = new Serializer(new SerializerOptions(versionTolerance: true, preserveObjectReferences: true));
+            var type = typeof(ByteMessage);
+            
+            MemoryStream GetStreamForManifest(string manifest)
+            {
+                var stream = new MemoryStream();
+                stream.WriteLengthEncodedByteArray(manifest.ToUtf8Bytes(), serializer.GetSerializerSession());
+                stream.Position = 0;
+                return stream;
+            }
+            
+            // This is used in serialized manifest, should be something like 'Hyperion.Tests.Bugs+ByteMessage, Hyperion.Tests'
+            var shortName = type.GetShortAssemblyQualifiedName();
+            var shortNameStream = GetStreamForManifest(shortName);
+            // Something like 'Hyperion.Tests.Bugs+ByteMessage, Hyperion.Tests, Version=0.9.11.0, Culture=neutral, PublicKeyToken=null'
+            var fullName = type.AssemblyQualifiedName;
+            var fullNameStream = GetStreamForManifest(fullName);
+            // Set bad assembly version to make deserialization fail
+            var fullNameWithUnknownVersion = fullName.Remove(fullName.IndexOf(", Version=")) + ", Version=999999, Culture=neutral, PublicKeyToken=null";
+            var fullNameWithUnknownVersionStream = GetStreamForManifest(fullNameWithUnknownVersion);
+
+            this.Invoking(_ => TypeEx.GetTypeFromManifestFull(shortNameStream, serializer.GetDeserializerSession()))
+                .Should().NotThrow("When assembly short name is specified in manifest, should work");
+            this.Invoking(_ => TypeEx.GetTypeFromManifestFull(fullNameStream, serializer.GetDeserializerSession()))
+                .Should().NotThrow("When assembly fully qualified name specified and name is correct, should work even before fix");
+            // This one was initially failing
+            this.Invoking(_ => TypeEx.GetTypeFromManifestFull(fullNameWithUnknownVersionStream, serializer.GetDeserializerSession()))
+                .Should().NotThrow("When assembly fully qualified name specified and unknown/wrong, type should be detected anyway");
+        }
+
+        [Fact]
+        public void TypeEx_ToQualifiedAssemblyName_should_strip_version_correctly_for_mscorlib_substitution()
+        {
+            var version = TypeEx.ToQualifiedAssemblyName(
+                "System.Collections.Immutable.ImmutableDictionary`2[[System.String, mscorlib,%core%],[System.Int32, mscorlib,%core%]]," +
+                " System.Collections.Immutable, Version=1.2.1.0, PublicKeyToken=b03f5f7f11d50a3a",
+                ignoreAssemblyVersion: true);
+
+            var coreAssemblyName = typeof(TypeEx).GetField("CoreAssemblyName", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null);
+            if (coreAssemblyName == null)
+                throw new Exception($"CoreAssemblyName private static field does not exist in {nameof(TypeEx)} class anymore");
+            
+            version.Should().Be("System.Collections.Immutable.ImmutableDictionary`2" +
+                                $"[[System.String, mscorlib{coreAssemblyName}],[System.Int32, mscorlib{coreAssemblyName}]], System.Collections.Immutable");
+        }
+        
+        [Fact]
+        public void TypeEx_ToQualifiedAssemblyName_should_strip_version_correctly_for_multiple_versions_specified()
+        {
+            var version = TypeEx.ToQualifiedAssemblyName(
+                "System.Collections.Immutable.ImmutableList`1[[Foo.Bar, Foo, Version=2019.12.10.1]], " +
+                "System.Collections.Immutable, Version=1.2.2.0, PublicKeyToken=b03f5f7f11d50a3a",
+                ignoreAssemblyVersion: true);
+
+            version.Should().Be("System.Collections.Immutable.ImmutableList`1[[Foo.Bar, Foo]], System.Collections.Immutable");
+        }
+
         [Fact]
         public void CanSerialieCustomType_bug()
         {

src/Hyperion.Tests/Hyperion.Tests.csproj

@@ -10,6 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.10.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(TestSdkVersion)" />
     <PackageReference Include="System.Collections.Immutable" Version="1.7.0" />
     <PackageReference Include="xunit" Version="$(XunitVersion)" />

src/Hyperion/Extensions/TypeEx.cs

@@ -130,11 +130,26 @@ private static Type GetTypeFromManifestName(Stream stream, DeserializerSession s
                     shortName = shortName.Replace("mscorlib,%core%", "System.Private.CoreLib,%core%");
                 }
 #endif
+                return LoadTypeByName(shortName);
+            });
+        }
 
-                var typename = ToQualifiedAssemblyName(shortName);
+        public static Type LoadTypeByName(string name)
+        {
+            try
+            {
+                // Try to load type name using strict version to avoid possible conflicts
+                // i.e. if there are different version available in GAC and locally
+                var typename = ToQualifiedAssemblyName(name, ignoreAssemblyVersion: false);
                 return Type.GetType(typename, true);
-            });
+            }
+            catch (FileLoadException)
+            {
+                var typename = ToQualifiedAssemblyName(name, ignoreAssemblyVersion: true);
+                return Type.GetType(typename, true);
+            }
         }
+        
         public static Type GetTypeFromManifestFull(Stream stream, DeserializerSession session)
         {
             var type = GetTypeFromManifestName(stream, session);
@@ -228,9 +243,16 @@ public static string GetShortAssemblyQualifiedName(this Type self)
             return name;
         }
 
-        public static string ToQualifiedAssemblyName(string shortName)
+        public static string ToQualifiedAssemblyName(string shortName, bool ignoreAssemblyVersion)
         {
+            // Strip out assembly version, if specified
+            if (ignoreAssemblyVersion)
+            {
+                shortName = cleanAssemblyVersionRegex.Replace(shortName, string.Empty);
+            }
+            
             var res = shortName.Replace(",%core%", CoreAssemblyName);
+            
             return res;
         }
 

src/Hyperion/Hyperion.csproj

@@ -24,6 +24,11 @@
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
 
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>Hyperion.Tests</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
 
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.6' ">
     <DefineConstants>$(DefineConstants);NETSTANDARD16</DefineConstants>

src/Hyperion/ValueSerializers/TypeSerializer.cs

@@ -66,8 +66,7 @@ public override object ReadValue(Stream stream, DeserializerSession session)
             if (shortname == null)
                 return null;
 
-            var name = TypeEx.ToQualifiedAssemblyName(shortname);
-            var type = Type.GetType(name,true);
+            var type = TypeEx.LoadTypeByName(shortname);
 
             //add the deserialized type to lookup
             if (session.Serializer.Options.PreserveObjectReferences)