fix: Reworks TenantResolver

src/Elders.Cronus/Exception/UnableToResolveTenantExeption.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Elders.Cronus.AspNetCore.Exeptions
+{
+    [Serializable]
+    // Important: This attribute is NOT inherited from Exception, and MUST be specified 
+    // otherwise serialization will fail with a SerializationException stating that
+    // "Type X in Assembly Y is not marked as serializable."
+    public class UnableToResolveTenantException : Exception
+    {
+        public UnableToResolveTenantException() { }
+
+        public UnableToResolveTenantException(string message) : this(message, null) { }
+
+        public UnableToResolveTenantException(string message, Exception innerException) : base(message, innerException) { }
+
+        protected UnableToResolveTenantException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+    }
+}

src/Elders.Cronus/Multitenancy/ITenantResolver.cs

@@ -1,6 +1,9 @@
-using Microsoft.Extensions.DependencyInjection;
+using Elders.Cronus.AspNetCore.Exeptions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Concurrent;
+using System.Linq;
 using System.Reflection;
 
 namespace Elders.Cronus.Multitenancy
@@ -12,18 +15,30 @@ public interface ITenantResolver
 
     public interface ITenantResolver<in T>
     {
+        /// <summary>
+        /// Resolves a teannt name from a specific source.
+        /// </summary>
+        /// <param name="source">The source from which the system will try to extract the tenant name.</param>
+        /// <returns>Returns the tenant name or empty string if the tenant resolving fails.</returns>
+        /// <remarks>
+        /// This method should never throw an exception. The system will try to resolve the tenant name
+        /// from several places based on the current execution chain. If the process still fails then
+        /// an exception will be thrown from the underlying execution.
+        /// </remarks>
         string Resolve(T source);
     }
 
     public class TenantResolver : ITenantResolver
     {
         ConcurrentDictionary<Type, ResolverCache> resolvers = new ConcurrentDictionary<Type, ResolverCache>();
 
+        private readonly TenantsOptions tenants;
         private readonly IServiceProvider serviceProvider;
 
-        public TenantResolver(IServiceProvider serviceProvider)
+        public TenantResolver(IServiceProvider serviceProvider, IOptions<TenantsOptions> tenantsOptions)
         {
             this.serviceProvider = serviceProvider;
+            this.tenants = tenantsOptions.Value;
         }
 
         public string Resolve(object source)
@@ -33,16 +48,28 @@ public string Resolve(object source)
             ResolverCache resolverCache;
             if (resolvers.TryGetValue(source.GetType(), out resolverCache) == false)
             {
-                var tenantResolverType = typeof(ITenantResolver<>);
-                var tenantResolverTypeGeneric = tenantResolverType.MakeGenericType(source.GetType());
-                var resolver = serviceProvider.GetRequiredService(tenantResolverTypeGeneric);
+                Type tenantResolverType = typeof(ITenantResolver<>);
+                Type tenantResolverTypeGeneric = tenantResolverType.MakeGenericType(source.GetType());
+                object resolver = serviceProvider.GetRequiredService(tenantResolverTypeGeneric);
                 MethodInfo resolveMethod = tenantResolverTypeGeneric.GetMethod("Resolve");
 
                 resolverCache = new ResolverCache(resolver, resolveMethod);
                 resolvers.TryAdd(source.GetType(), resolverCache);
             }
 
-            return resolverCache.GetTenantFrom(source);
+            string tenant = resolverCache.GetTenantFrom(source);
+
+            if (string.IsNullOrEmpty(tenant) == false)
+            {
+                return tenant;
+            }
+            else
+            {
+                if (tenants.Tenants.Count() == 1)
+                    return tenants.Tenants.Single();
+            }
+
+            throw new UnableToResolveTenantException("Unable to resolve tenant.");
         }
 
         class ResolverCache