Azure
diff --git a/‎common/ManagementCoreShared/ClientContext.cs‎
Lines changed: 50 additions & 0 deletions b/‎common/ManagementCoreShared/ClientContext.cs‎
Lines changed: 50 additions & 0 deletions
diff --git a/‎…TestShared/ManagementRecordedTestBase.cs‎ ‎…ed/Current/ManagementRecordedTestBase.cs‎common/ManagementTestShared/ManagementRecordedTestBase.cs renamed to common/ManagementTestShared/Current/ManagementRecordedTestBase.cs
Lines changed: 1 addition & 8 deletions b/‎…TestShared/ManagementRecordedTestBase.cs‎ ‎…ed/Current/ManagementRecordedTestBase.cs‎common/ManagementTestShared/ManagementRecordedTestBase.cs renamed to common/ManagementTestShared/Current/ManagementRecordedTestBase.cs
Lines changed: 1 addition & 8 deletions
diff --git a/‎…TestShared/ResourceGroupCleanupPolicy.cs‎ ‎…ed/Current/ResourceGroupCleanupPolicy.cs‎common/ManagementTestShared/ResourceGroupCleanupPolicy.cs renamed to common/ManagementTestShared/Current/ResourceGroupCleanupPolicy.cs
Lines changed: 5 additions & 1 deletion b/‎…TestShared/ResourceGroupCleanupPolicy.cs‎ ‎…ed/Current/ResourceGroupCleanupPolicy.cs‎common/ManagementTestShared/ResourceGroupCleanupPolicy.cs renamed to common/ManagementTestShared/Current/ResourceGroupCleanupPolicy.cs
Lines changed: 5 additions & 1 deletion
diff --git a/‎common/ManagementTestShared/Redesign/JsonHelper.cs‎
Lines changed: 50 additions & 0 deletions b/‎common/ManagementTestShared/Redesign/JsonHelper.cs‎
Lines changed: 50 additions & 0 deletions
diff --git a/‎common/ManagementTestShared/Redesign/ManagementGroupCleanupPolicy.cs‎
Lines changed: 37 additions & 0 deletions b/‎common/ManagementTestShared/Redesign/ManagementGroupCleanupPolicy.cs‎
Lines changed: 37 additions & 0 deletions
diff --git a/‎common/ManagementTestShared/Redesign/ManagementRecordedTestBase.cs‎
Lines changed: 214 additions & 0 deletions b/‎common/ManagementTestShared/Redesign/ManagementRecordedTestBase.cs‎
Lines changed: 214 additions & 0 deletions
@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using Azure.Core;
+using Azure.Core.Pipeline;
+
+namespace Azure.ResourceManager.Core
+{
+    /// <summary>
+    /// helper class
+    /// </summary>
+    internal class ClientContext
+    {
+        /// <summary>
+        /// client options
+        /// </summary>
+        public ArmClientOptions ClientOptions { get; set; }
+
+        /// <summary>
+        /// credential
+        /// </summary>
+        public TokenCredential Credential { get; set; }
+
+        /// <summary>
+        /// baseuri
+        /// </summary>
+        public Uri BaseUri { get; set; }
+
+        /// <summary>
+        /// pipeline
+        /// </summary>
+        public HttpPipeline Pipeline { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClientContext"/> class.
+        /// </summary>
+        /// <param name="clientOptions"></param>
+        /// <param name="credential"></param>
+        /// <param name="uri"></param>
+        /// <param name="pipeline"></param>
+        internal ClientContext(ArmClientOptions clientOptions, TokenCredential credential, Uri uri, HttpPipeline pipeline)
+        {
+            ClientOptions = clientOptions;
+            Credential = credential;
+            BaseUri = uri;
+            Pipeline = pipeline;
+        }
+    }
+}
@@ -27,14 +27,7 @@ protected ManagementRecordedTestBase(bool isAsync, RecordedTestMode mode) : base
 
         protected ValueTask<Response<T>> WaitForCompletionAsync<T>(Operation<T> operation)
         {
-            if (Mode == RecordedTestMode.Playback)
-            {
-                return operation.WaitForCompletionAsync(ZeroPollingInterval, default);
-            }
-            else
-            {
-                return operation.WaitForCompletionAsync();
-            }
+            return operation.WaitForCompletionAsync();
         }
 
         protected ResourcesManagementClient GetResourceManagementClient()
 
@@ -11,6 +11,7 @@ namespace Azure.ResourceManager.TestFramework
 {
     public class ResourceGroupCleanupPolicy : HttpPipelineSynchronousPolicy
     {
+        private readonly object _listLock = new object();
         private Regex _resourceGroupPattern = new Regex(@"/subscriptions/[^/]+/resourcegroups/([^?/]+)\?api-version");
         private readonly IList<string> _resourceGroupCreated = new List<string>();
 
@@ -26,7 +27,10 @@ public override void OnSendingRequest(HttpMessage message)
                 var match = _resourceGroupPattern.Match(message.Request.Uri.ToString());
                 if (match.Success)
                 {
-                    _resourceGroupCreated.Add(match.Groups[1].Value);
+                    lock (_listLock)
+                    {
+                        _resourceGroupCreated.Add(match.Groups[1].Value);
+                    }
                 }
             }
         }
 
@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.IO;
+using System.Text;
+using System.Text.Json;
+using Azure.Core;
+using NUnit.Framework;
+
+namespace Azure.ResourceManager.TestFramework
+{
+    internal static class JsonHelper
+    {
+        private static readonly JsonWriterOptions PrettyJsonOptions = new JsonWriterOptions() { Indented = true };
+        private static readonly JsonWriterOptions CompactJsonOptions = new JsonWriterOptions();
+
+        /// <summary>
+        /// This methods serialize the complete resource data to string.
+        /// </summary>
+        /// <param name="data"> Resource data that implements <see cref="IUtf8JsonSerializable"/>. </param>
+        /// <returns> Json string represent the data. </returns>
+        public static string SerializeToString(IUtf8JsonSerializable data, bool indented = false)
+        {
+            var stream = new MemoryStream();
+            Utf8JsonWriter writer = new(stream, indented ? PrettyJsonOptions : CompactJsonOptions);
+            writer.WriteObjectValue(data);
+            writer.Flush();
+            return Encoding.UTF8.GetString(stream.ToArray());
+        }
+
+        /// <summary>
+        /// This methods serialize the data properties to string under "properties" tag.
+        /// Please note if data has top level properties needed that goes outside of "properties",
+        /// use <see cref="JsonHelper.SerializeToString"/> instead.
+        /// </summary>
+        /// <param name="data"> data that implements <see cref="IUtf8JsonSerializable"/>. </param>
+        /// <returns> Json string represent the data object's properties. </returns>
+        public static string SerializePropertiesToString(IUtf8JsonSerializable data, bool indented = false)
+        {
+            var stream = new MemoryStream();
+            Utf8JsonWriter writer = new(stream, indented ? PrettyJsonOptions : CompactJsonOptions);
+            writer.WriteStartObject();
+            writer.WritePropertyName("properties");
+            writer.WriteObjectValue(data);
+            writer.WriteEndObject();
+            writer.Flush();
+            return Encoding.UTF8.GetString(stream.ToArray());
+        }
+    }
+}
@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Azure.Core;
+using Azure.Core.Pipeline;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace Azure.ResourceManager.TestFramework
+{
+    public class ManagementGroupCleanupPolicy : HttpPipelineSynchronousPolicy
+    {
+        private readonly object _listLock = new object();
+        private Regex _mgmtGroupPattern = new Regex(@"(/providers/Microsoft\.Management/managementGroups/[^?/]+)\?api-version");
+        private readonly IList<string> _mgmtGroupCreated = new List<string>();
+
+        public IList<string> ManagementGroupsCreated
+        {
+            get { return _mgmtGroupCreated; }
+        }
+
+        public override void OnSendingRequest(HttpMessage message)
+        {
+            if (message.Request.Method == RequestMethod.Put)
+            {
+                var match = _mgmtGroupPattern.Match(message.Request.Uri.ToString());
+                if (match.Success)
+                {
+                    lock (_listLock)
+                    {
+                        _mgmtGroupCreated.Add(match.Groups[1].Value);
+                    }
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,214 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Azure.Core;
+using Azure.Core.TestFramework;
+using Azure.ResourceManager.Core;
+using Castle.DynamicProxy;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Azure.ResourceManager.TestFramework
+{
+    public abstract class ManagementRecordedTestBase<TEnvironment> : RecordedTestBase<TEnvironment>
+        where TEnvironment: TestEnvironment, new()
+    {
+        protected ResourceGroupCleanupPolicy ResourceGroupCleanupPolicy = new ResourceGroupCleanupPolicy();
+
+        protected ResourceGroupCleanupPolicy OneTimeResourceGroupCleanupPolicy = new ResourceGroupCleanupPolicy();
+
+        protected ManagementGroupCleanupPolicy ManagementGroupCleanupPolicy = new ManagementGroupCleanupPolicy();
+
+        protected ManagementGroupCleanupPolicy OneTimeManagementGroupCleanupPolicy = new ManagementGroupCleanupPolicy();
+
+        protected ArmClient GlobalClient { get; private set; }
+
+        public TestEnvironment SessionEnvironment { get; private set; }
+
+        public TestRecording SessionRecording { get; private set; }
+
+        private ArmClient _cleanupClient;
+
+        protected ManagementRecordedTestBase(bool isAsync) : base(isAsync)
+        {
+            SessionEnvironment = new TEnvironment();
+            SessionEnvironment.Mode = Mode;
+            Initialize();
+        }
+
+        protected ManagementRecordedTestBase(bool isAsync, RecordedTestMode mode) : base(isAsync, mode)
+        {
+            SessionEnvironment = new TEnvironment();
+            SessionEnvironment.Mode = Mode;
+            Initialize();
+        }
+
+        private void Initialize()
+        {
+            if (Mode == RecordedTestMode.Playback)
+            {
+                var pollField = typeof(OperationInternals).GetField("<DefaultPollingInterval>k__BackingField", BindingFlags.Static | BindingFlags.NonPublic);
+                pollField.SetValue(null, TimeSpan.Zero);
+            }
+        }
+
+        private ArmClient GetCleanupClient()
+        {
+            if (Mode != RecordedTestMode.Playback)
+            {
+                return new ArmClient(
+                        TestEnvironment.SubscriptionId,
+                        TestEnvironment.Credential,
+                        new ArmClientOptions());
+            }
+            return null;
+        }
+
+        protected TClient InstrumentClientExtension<TClient>(TClient client) => (TClient)InstrumentClient(typeof(TClient), client, new IInterceptor[] { new ManagementInterceptor(this) });
+
+        protected ArmClient GetArmClient(ArmClientOptions clientOptions = default)
+        {
+            var options = InstrumentClientOptions(clientOptions ?? new ArmClientOptions());
+            options.AddPolicy(ResourceGroupCleanupPolicy, HttpPipelinePosition.PerCall);
+            options.AddPolicy(ManagementGroupCleanupPolicy, HttpPipelinePosition.PerCall);
+
+            return CreateClient<ArmClient>(
+                TestEnvironment.SubscriptionId,
+                TestEnvironment.Credential,
+                options);
+        }
+
+        [SetUp]
+        protected void CreateCleanupClient()
+        {
+            _cleanupClient ??= GetCleanupClient();
+        }
+
+        [TearDown]
+        protected void CleanupResourceGroups()
+        {
+            if (Mode != RecordedTestMode.Playback)
+            {
+                Parallel.ForEach(ResourceGroupCleanupPolicy.ResourceGroupsCreated, resourceGroup =>
+                {
+                    try
+                    {
+                        var sub = _cleanupClient.GetSubscriptions().TryGet(TestEnvironment.SubscriptionId);
+                        sub?.GetResourceGroups().Get(resourceGroup).Value.StartDelete();
+                    }
+                    catch (RequestFailedException e) when (e.Status == 404)
+                    {
+                        //we assume the test case cleaned it up if it no longer exists.
+                    }
+                });
+
+                Parallel.ForEach(ManagementGroupCleanupPolicy.ManagementGroupsCreated, mgmtGroupId =>
+                {
+                    try
+                    {
+                        _cleanupClient.GetManagementGroupOperations(mgmtGroupId).StartDelete();
+                    }
+                    catch (RequestFailedException e) when (e.Status == 404 || e.Status == 403)
+                    {
+                        //we assume the test case cleaned it up if it no longer exists.
+                    }
+                });
+            }
+        }
+
+        private void StartSessionRecording()
+        {
+            // Only create test recordings for the latest version of the service
+            TestContext.TestAdapter test = TestContext.CurrentContext.Test;
+            if (Mode != RecordedTestMode.Live &&
+                test.Properties.ContainsKey("SkipRecordings"))
+            {
+                throw new IgnoreException((string)test.Properties.Get("SkipRecordings"));
+            }
+            SessionRecording = new TestRecording(Mode, GetSessionFilePath(), Sanitizer, Matcher);
+            SessionEnvironment.SetRecording(SessionRecording);
+            ValidateClientInstrumentation = SessionRecording.HasRequests;
+        }
+
+        protected void StopSessionRecording()
+        {
+            if (ValidateClientInstrumentation)
+            {
+                throw new InvalidOperationException("The test didn't instrument any clients but had recordings. Please call InstrumentClient for the client being recorded.");
+            }
+
+            SessionRecording?.Dispose(true);
+            GlobalClient = null;
+        }
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            if (!HasOneTimeSetup())
+                return;
+
+            StartSessionRecording();
+
+            var options = InstrumentClientOptions(new ArmClientOptions(), SessionRecording);
+            options.AddPolicy(OneTimeResourceGroupCleanupPolicy, HttpPipelinePosition.PerCall);
+            options.AddPolicy(OneTimeManagementGroupCleanupPolicy, HttpPipelinePosition.PerCall);
+
+            GlobalClient = CreateClient<ArmClient>(
+                SessionEnvironment.SubscriptionId,
+                SessionEnvironment.Credential,
+                options);
+        }
+
+        private bool HasOneTimeSetup()
+        {
+            HashSet<Type> types = new HashSet<Type>();
+            Type type = GetType();
+            Type endType = typeof(ManagementRecordedTestBase<TEnvironment>);
+            while (type != endType)
+            {
+                types.Add(type);
+                type = type.BaseType;
+            }
+
+            var methods = GetType().GetMethods().Where(m => types.Contains(m.DeclaringType));
+            foreach (var method in methods)
+            {
+                foreach (var attr in method.GetCustomAttributes(false))
+                {
+                    if (attr is OneTimeSetUpAttribute)
+                        return true;
+                }
+            }
+            return false;
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeCleanupResourceGroups()
+        {
+            if (Mode != RecordedTestMode.Playback)
+            {
+                Parallel.ForEach(OneTimeResourceGroupCleanupPolicy.ResourceGroupsCreated, resourceGroup =>
+                {
+                    var sub = _cleanupClient.GetSubscriptions().TryGet(SessionEnvironment.SubscriptionId);
+                    sub?.GetResourceGroups().Get(resourceGroup).Value.StartDelete();
+                });
+                Parallel.ForEach(OneTimeManagementGroupCleanupPolicy.ManagementGroupsCreated, mgmtGroupId =>
+                {
+                    _cleanupClient.GetManagementGroupOperations(mgmtGroupId).StartDelete();
+                });
+            }
+
+            if (!(GlobalClient is null))
+                throw new InvalidOperationException("StopSessionRecording was never called please make sure you call that at the end of your OneTimeSetup");
+        }
+
+        protected override object InstrumentOperation(Type operationType, object operation)
+        {
+            return InstrumentMgmtOperation(operationType, operation, new ManagementInterceptor(this));
+        }
+    }
+}
Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,7 @@ protected ManagementRecordedTestBase(bool isAsync, RecordedTestMode mode) : base`
`27`	`27`
`28`	`28`	`protected ValueTask<Response<T>> WaitForCompletionAsync<T>(Operation<T> operation)`
`29`	`29`	`{`
`30`		`- if (Mode == RecordedTestMode.Playback)`
`31`		`- {`
`32`		`- return operation.WaitForCompletionAsync(ZeroPollingInterval, default);`
`33`		`- }`
`34`		`- else`
`35`		`- {`
`36`		`- return operation.WaitForCompletionAsync();`
`37`		`- }`
	`30`	`+ return operation.WaitForCompletionAsync();`
`38`	`31`	`}`
`39`	`32`
`40`	`33`	`protected ResourcesManagementClient GetResourceManagementClient()`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ namespace Azure.ResourceManager.TestFramework`
`11`	`11`	`{`
`12`	`12`	`public class ResourceGroupCleanupPolicy : HttpPipelineSynchronousPolicy`
`13`	`13`	`{`
	`14`	`+ private readonly object _listLock = new object();`
`14`	`15`	`private Regex _resourceGroupPattern = new Regex(@"/subscriptions/[^/]+/resourcegroups/([^?/]+)\?api-version");`
`15`	`16`	`private readonly IList<string> _resourceGroupCreated = new List<string>();`
`16`	`17`
`@@ -26,7 +27,10 @@ public override void OnSendingRequest(HttpMessage message)`
`26`	`27`	`var match = _resourceGroupPattern.Match(message.Request.Uri.ToString());`
`27`	`28`	`if (match.Success)`
`28`	`29`	`{`
`29`		`- _resourceGroupCreated.Add(match.Groups[1].Value);`
	`30`	`+ lock (_listLock)`
	`31`	`+ {`
	`32`	`+ _resourceGroupCreated.Add(match.Groups[1].Value);`
	`33`	`+ }`
`30`	`34`	`}`
`31`	`35`	`}`
`32`	`36`	`}`