Migrate storage tests to test proxy (Azure#26662)

* Migrate storage tests to test proxy

* Remove unused method

* Update empty request body recordings

* Reset upstream URI on each retry

* remove pct encoding from header values

* Datalake session file fixes

* more decoding

* datalake passing .net 6

* Datalake passing on all platforms

* Files passing

* .NET framework sanitization

* Avoid nesting proxy transport

* Fix sanitizer

* Undo unnecessary re-recording

* revert more

* fix

Author: JoshLove-msft

sdk/core/Azure.Core.TestFramework/src/ProxyTransport.cs

@@ -45,23 +45,49 @@ public ProxyTransport(TestProxy proxy, HttpPipelineTransport transport, TestReco
             _filter = filter;
         }
 
-        public override void Process(HttpMessage message)
-        {
-            RedirectToTestProxy(message);
-            _innerTransport.Process(message);
-            ProcessResponseAsync(message, false).EnsureCompleted();
-        }
+        public override void Process(HttpMessage message) =>
+            ProcessAsyncInternalAsync(message, false).EnsureCompleted();
 
-        public override async ValueTask ProcessAsync(HttpMessage message)
+        public override async ValueTask ProcessAsync(HttpMessage message) =>
+            await ProcessAsyncInternalAsync(message, true);
+
+        private async Task ProcessAsyncInternalAsync(HttpMessage message, bool async)
         {
-            RedirectToTestProxy(message);
-            await _innerTransport.ProcessAsync(message);
-            await ProcessResponseAsync(message, true);
+            try
+            {
+                RedirectToTestProxy(message);
+                if (async)
+                {
+                    await _innerTransport.ProcessAsync(message);
+                }
+                else
+                {
+                    _innerTransport.Process(message);
+                }
+
+                await ProcessResponseAsync(message, true);
+            }
+            finally
+            {
+                // revert the original URI - this is important for tests that rely on aspects of the URI in the pipeline
+                // e.g. KeyVault caches tokens based on URI
+                message.Request.Headers.TryGetValue("x-recording-upstream-base-uri", out string original);
+
+                var originalBaseUri = new Uri(original);
+                message.Request.Uri.Scheme = originalBaseUri.Scheme;
+                message.Request.Uri.Host = originalBaseUri.Host;
+                message.Request.Uri.Port = originalBaseUri.Port;
+
+                if (_isWebRequestTransport)
+                {
+                    ServicePointManager.ServerCertificateValidationCallback -= ServerCertificateCustomValidationCallback;
+                }
+            }
         }
 
         private async Task ProcessResponseAsync(HttpMessage message, bool async)
         {
-            if (message.Response.Headers.Contains("x-request-mismatch"))
+            if (message.HasResponse && message.Response.Headers.Contains("x-request-mismatch"))
             {
                 var streamReader = new StreamReader(message.Response.ContentStream);
                 string response;
@@ -76,20 +102,6 @@ private async Task ProcessResponseAsync(HttpMessage message, bool async)
                 using var doc = JsonDocument.Parse(response);
                 throw new TestRecordingMismatchException(doc.RootElement.GetProperty("Message").GetString());
             }
-
-            // revert the original URI - this is important for tests that rely on aspects of the URI in the pipeline
-            // e.g. KeyVault caches tokens based on URI
-            message.Request.Headers.TryGetValue("x-recording-upstream-base-uri", out string original);
-
-            var originalBaseUri = new Uri(original);
-            message.Request.Uri.Scheme = originalBaseUri.Scheme;
-            message.Request.Uri.Host = originalBaseUri.Host;
-            message.Request.Uri.Port = originalBaseUri.Port;
-
-            if (_isWebRequestTransport)
-            {
-                ServicePointManager.ServerCertificateValidationCallback -= ServerCertificateCustomValidationCallback;
-            }
         }
 
         public override Request CreateRequest()
@@ -137,17 +149,14 @@ private void RedirectToTestProxy(HttpMessage message)
             request.Headers.SetValue("x-recording-id", _recording.RecordingId);
             request.Headers.SetValue("x-recording-mode", _recording.Mode.ToString().ToLower());
 
-            // Ensure x-recording-upstream-base-uri header is only set once, since the same HttpMessage will be reused on retries
-            if (!request.Headers.Contains("x-recording-upstream-base-uri"))
+            // Intentionally reset the upstream URI in case the request URI changes between retries - e.g. when using GeoRedundant secondary Storage
+            var baseUri = new RequestUriBuilder()
             {
-                var baseUri = new RequestUriBuilder()
-                {
-                    Scheme = request.Uri.Scheme,
-                    Host = request.Uri.Host,
-                    Port = request.Uri.Port,
-                };
-                request.Headers.SetValue("x-recording-upstream-base-uri", baseUri.ToString());
-            }
+                Scheme = request.Uri.Scheme,
+                Host = request.Uri.Host,
+                Port = request.Uri.Port,
+            };
+            request.Headers.SetValue("x-recording-upstream-base-uri", baseUri.ToString());
 
             // for some reason using localhost instead of the ip address causes slowness when combined with SSL callback being specified
             request.Uri.Host = TestProxy.IpAddress;

sdk/core/Azure.Core.TestFramework/src/TestRecording.cs

@@ -343,6 +343,10 @@ public HttpPipelineTransport CreateTransport(HttpPipelineTransport currentTransp
         {
             if (!_useLegacyTransport && Mode != RecordedTestMode.Live)
             {
+                if (currentTransport is ProxyTransport)
+                {
+                    return currentTransport;
+                }
                 return new ProxyTransport(_proxy, currentTransport, this, () => _disableRecording.Value);
             }
             return Mode switch