Merge pull request #29 from profet23/dev

Proposed solution for bug #26

Author: leastprivilege

src/IdentityModel.AspNetCore.OAuth2Introspection/Infrastructure/AsyncLazy.cs

@@ -6,10 +6,42 @@
 
 namespace IdentityModel.AspNetCore.OAuth2Introspection.Infrastructure
 {
-    internal class AsyncLazy<T> : Lazy<Task<T>>
+    internal sealed class AsyncLazy<T>
     {
-        public AsyncLazy(Func<Task<T>> taskFactory) :
-            base(() => Task.Factory.StartNew(taskFactory).Unwrap())
-        { }
+        private Lazy<Task<T>> _lazyTaskFactory;
+        private readonly Func<Task<T>> _taskFactory;
+        private readonly object _lazyInitializationGuard = new object();
+
+        public AsyncLazy(Func<Task<T>> taskFactory)
+        {
+            _taskFactory = taskFactory;
+            _lazyTaskFactory = InitLazy(_taskFactory);
+        }
+
+        public Task<T> Value
+        {
+            get
+            {
+                //If the lazy value is not yet created, we should just return the lazy value (which will create it)
+                //If the value has been created and the value (which is a Task<T>) is not faulted, we should just return the value;
+                if (!(_lazyTaskFactory.IsValueCreated && _lazyTaskFactory.Value.IsFaulted))
+                    return _lazyTaskFactory.Value;
+
+                lock (_lazyInitializationGuard)
+                {
+                    if (_lazyTaskFactory.IsValueCreated && _lazyTaskFactory.Value.IsFaulted)
+                    {
+                        _lazyTaskFactory = InitLazy(_taskFactory);
+                    }
+
+                    return _lazyTaskFactory.Value;
+                }
+            }
+        }
+
+        private static Lazy<Task<T>> InitLazy(Func<Task<T>> taskFactory)
+        {
+            return new Lazy<Task<T>>(() => Task.Run(taskFactory));
+        }
     }
 }

test/Tests/Introspection.cs

@@ -164,5 +164,27 @@ public async Task ActiveToken_With_SavedToken_And_Caching()
 
             responseData.Should().Contain("token", expectedToken);
         }
+
+        [Fact]
+        public async Task ActiveToken_With_Discovery_Unavailable_On_First_Request()
+        {
+            var handler = new DiscoveryEndpointHandler();
+
+            var client = PipelineFactory.CreateClient((o) =>
+            {
+                _options(o);
+                o.DiscoveryHttpHandler = handler;
+                o.IntrospectionHttpHandler = new IntrospectionEndpointHandler(IntrospectionEndpointHandler.Behavior.Active);
+            });
+
+            client.SetBearerToken("sometoken");
+
+            handler.IsFailureTest = true;
+            await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.GetAsync("http://test"));
+            
+            handler.IsFailureTest = false;
+            var result = await client.GetAsync("http://test");
+            result.StatusCode.Should().Be(HttpStatusCode.OK);
+        }
     }
 }

test/Tests/Util/DiscoveryEndpointHandler.cs

@@ -13,8 +13,15 @@ class DiscoveryEndpointHandler : HttpMessageHandler
     {
         public string Endpoint { get; set; }
 
+        public bool IsFailureTest { get; set; } = false;
+
         protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
         {
+            if (IsFailureTest)
+            {
+                return Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound));
+            }
+
             if (request.RequestUri.AbsoluteUri.ToString() == "https://authority.com/.well-known/openid-configuration")
             {
                 Endpoint = request.RequestUri.AbsoluteUri;