Remove Storage TestController (Azure#18470)

Ziyue Zheng · web-flow · commit 7d4bc9160d46 · 2022-06-17T15:25:12.000+08:00
* Remove TestController

* Update StorageBlobTests.cs

* Update StorageTestRunner.cs

* Update StorageTestRunner.cs
diff --git a/src/Storage/Storage.Management.Test/ScenarioTests/StorageBlobTests.cs b/src/Storage/Storage.Management.Test/ScenarioTests/StorageBlobTests.cs
@@ -12,107 +12,101 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
-
-using Microsoft.Azure.ServiceManagement.Common.Models;
 using Microsoft.WindowsAzure.Commands.ScenarioTest;
-using Microsoft.WindowsAzure.Commands.Test.Utilities.Common;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace Microsoft.Azure.Commands.Management.Storage.Test.ScenarioTests
 {
-    public class StorageBlobTests : RMTestBase
+    public class StorageBlobTests : StorageTestRunner
     {
-        public XunitTracingInterceptor _logger;
-
         public StorageBlobTests(ITestOutputHelper output)
+            : base(output)
         {
-            _logger = new XunitTracingInterceptor(output);
-            XunitTracingInterceptor.AddToContext(_logger);
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobIsVersioningEnabled()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobIsVersioningEnabled");
+            TestRunner.RunTestScript("Test-StorageBlobIsVersioningEnabled");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobContainer()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainer");
+            TestRunner.RunTestScript("Test-StorageBlobContainer");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobContainerEncryptionScope()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerEncryptionScope");
-        }        
+            TestRunner.RunTestScript("Test-StorageBlobContainerEncryptionScope");
+        }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobContainerLegalHold()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerLegalHold");
+            TestRunner.RunTestScript("Test-StorageBlobContainerLegalHold");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobContainerImmutabilityPolicy()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerImmutabilityPolicy");
+            TestRunner.RunTestScript("Test-StorageBlobContainerImmutabilityPolicy");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobServiceProperties()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobServiceProperties");
-        }    
+            TestRunner.RunTestScript("Test-StorageBlobServiceProperties");
+        }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobORS()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobORS");
+            TestRunner.RunTestScript("Test-StorageBlobORS");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobRestore()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobRestore");
+            TestRunner.RunTestScript("Test-StorageBlobRestore");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobChangeFeed()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobChangeFeed");
+            TestRunner.RunTestScript("Test-StorageBlobChangeFeed");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobContainerSoftDelete()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerSoftDelete");
+            TestRunner.RunTestScript("Test-StorageBlobContainerSoftDelete");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobLastAccessTimeTracking()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobLastAccessTimeTracking");
+            TestRunner.RunTestScript("Test-StorageBlobLastAccessTimeTracking");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageBlobContainerVLW()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerVLW");
+            TestRunner.RunTestScript("Test-StorageBlobContainerVLW");
         }
     }
 }
diff --git a/src/Storage/Storage.Management.Test/ScenarioTests/StorageDataPlaneTests.cs b/src/Storage/Storage.Management.Test/ScenarioTests/StorageDataPlaneTests.cs
@@ -12,83 +12,72 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
-using System;
-using System.Collections;
-using System.Collections.ObjectModel;
-using System.Management.Automation;
 using Xunit;
 using Xunit.Abstractions;
-using System.Diagnostics;
-using Microsoft.Azure.ServiceManagement.Common.Models;
 using Microsoft.WindowsAzure.Commands.ScenarioTest;
-using Microsoft.WindowsAzure.Commands.Test.Utilities.Common;
-using Microsoft.Azure.Management.Internal.Resources;
-using Microsoft.Azure.Management.Storage;
 using Microsoft.Rest.ClientRuntime.Azure.TestFramework;
 
 namespace Microsoft.Azure.Commands.Management.Storage.Test.ScenarioTests
 {
-    public class StorageDataPlaneTests : RMTestBase
+    public class StorageDataPlaneTests : StorageTestRunner
     {
-        public XunitTracingInterceptor _logger;
         private string resourceGroupName;
         private string storageAccountName;
 
         public StorageDataPlaneTests(ITestOutputHelper output)
+            : base(output)
         {
             resourceGroupName = TestUtilities.GenerateName();
             storageAccountName = "sto" + resourceGroupName;
-            _logger = new XunitTracingInterceptor(output);
-            XunitTracingInterceptor.AddToContext(_logger);
         }
 
         [Fact]
         [Trait(Category.RunType, Category.LiveOnly)]
         public void TestBlob()
         {
-            TestController.NewInstance.RunPsTest(_logger, $"Test-Blob -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
+            TestRunner.RunTestScript($"Test-Blob -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
         }
 
         [Fact]
         [Trait(Category.RunType, Category.LiveOnly)]
         public void TestFile()
         {
-            TestController.NewInstance.RunPsTest(_logger, $"Test-File -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
+            TestRunner.RunTestScript($"Test-File -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
         }
 
         [Fact]
         [Trait(Category.RunType, Category.LiveOnly)]
         public void TestBlobFileCopy()
         {
-            TestController.NewInstance.RunPsTest(_logger, $"Test-BlobFileCopy -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
+            TestRunner.RunTestScript($"Test-BlobFileCopy -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
         }
 
         [Fact]
         [Trait(Category.RunType, Category.LiveOnly)]
         public void TestTable()
         {
-            TestController.NewInstance.RunPsTest(_logger, $"Test-Table -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
+            TestRunner.RunTestScript($"Test-Table -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
         }
 
         [Fact]
         [Trait(Category.RunType, Category.LiveOnly)]
         public void TestQueue()
         {
-            TestController.NewInstance.RunPsTest(_logger, $"Test-Queue -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
+            TestRunner.RunTestScript($"Test-Queue -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
         }
 
         [Fact]
         [Trait(Category.RunType, Category.LiveOnly)]
         public void TestCommon()
         {
-            TestController.NewInstance.RunPsTest(_logger, $"Test-Common -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
+            TestRunner.RunTestScript($"Test-Common -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
         }
 
         [Fact]
         [Trait(Category.RunType, Category.LiveOnly)]
         public void TestDatalakeGen2()
         {
-            TestController.NewInstance.RunPsTest(_logger, $"Test-DatalakeGen2 -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
+            TestRunner.RunTestScript($"Test-DatalakeGen2 -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");
         }
     }
 }
diff --git a/src/Storage/Storage.Management.Test/ScenarioTests/StorageFileTests.cs b/src/Storage/Storage.Management.Test/ScenarioTests/StorageFileTests.cs
@@ -12,65 +12,59 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
-
-using Microsoft.Azure.ServiceManagement.Common.Models;
 using Microsoft.WindowsAzure.Commands.ScenarioTest;
-using Microsoft.WindowsAzure.Commands.Test.Utilities.Common;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace Microsoft.Azure.Commands.Management.Storage.Test.ScenarioTests
 {
-    public class StorageFileTests : RMTestBase
+    public class StorageFileTests : StorageTestRunner
     {
-        public XunitTracingInterceptor _logger;
-
         public StorageFileTests(ITestOutputHelper output)
+            : base(output)
         {
-            _logger = new XunitTracingInterceptor(output);
-            XunitTracingInterceptor.AddToContext(_logger);
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageFileShare()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageFileShare");
+            TestRunner.RunTestScript("Test-StorageFileShare");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestStorageFileShareGetUsage()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-StorageFileShareGetUsage");
+            TestRunner.RunTestScript("Test-StorageFileShareGetUsage");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestShareSoftDeletee()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-ShareSoftDelete");
+            TestRunner.RunTestScript("Test-ShareSoftDelete");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestShareSnapshot()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-ShareSnapshot");
+            TestRunner.RunTestScript("Test-ShareSnapshot");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestFileServiceProperties()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-FileServiceProperties");
+            TestRunner.RunTestScript("Test-FileServiceProperties");
         }
 
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void TestAzureStorageShareNFS()
         {
-            TestController.NewInstance.RunPsTest(_logger, "Test-AzureStorageShareNFS");
-        }        
+            TestRunner.RunTestScript("Test-AzureStorageShareNFS");
+        }
     }
 }
diff --git a/src/Storage/Storage.Management.Test/ScenarioTests/StorageTestRunner.cs b/src/Storage/Storage.Management.Test/ScenarioTests/StorageTestRunner.cs
@@ -13,6 +13,7 @@
 // ----------------------------------------------------------------------------------
 
 using Microsoft.Azure.Commands.TestFx;
+using System.Collections.Generic;
 using Xunit.Abstractions;
 
 namespace Microsoft.Azure.Commands.Management.Storage.Test
@@ -28,13 +29,26 @@ protected StorageTestRunner(ITestOutputHelper output)
                 .WithProjectSubfolderForTests("ScenarioTests")
                 .WithCommonPsScripts(new[]
                 {
-                    @"Common.ps1", @"../AzureRM.Resources.ps1"
+                    @"Common.ps1",
+                    @"../AzureRM.Resources.ps1"
                 })
                 .WithNewRmModules(helper => new[]
                 {
                     helper.RMProfileModule,
                     helper.RMStorageModule
                 })
+                .WithNewRecordMatcherArguments(
+                    userAgentsToIgnore: new Dictionary<string, string>
+                    {
+                        {"Microsoft.Azure.Management.Resources.ResourceManagementClient", "2016-02-01"}
+                    },
+                    resourceProviders: new Dictionary<string, string>
+                    {
+                        {"Microsoft.Resources", null},
+                        {"Microsoft.Features", null},
+                        {"Microsoft.Authorization", null}
+                    }
+                )
                 .Build();
         }
     }
diff --git a/src/Storage/Storage.Management.Test/TestController.cs b/src/Storage/Storage.Management.Test/TestController.cs

Original file line number	Diff line number	Diff line change
`@@ -12,107 +12,101 @@`
`12`	`12`	`// limitations under the License.`
`13`	`13`	`// ----------------------------------------------------------------------------------`
`14`	`14`
`15`		`-`
`16`		`-using Microsoft.Azure.ServiceManagement.Common.Models;`
`17`	`15`	`using Microsoft.WindowsAzure.Commands.ScenarioTest;`
`18`		`-using Microsoft.WindowsAzure.Commands.Test.Utilities.Common;`
`19`	`16`	`using Xunit;`
`20`	`17`	`using Xunit.Abstractions;`
`21`	`18`
`22`	`19`	`namespace Microsoft.Azure.Commands.Management.Storage.Test.ScenarioTests`
`23`	`20`	`{`
`24`		`- public class StorageBlobTests : RMTestBase`
	`21`	`+ public class StorageBlobTests : StorageTestRunner`
`25`	`22`	`{`
`26`		`- public XunitTracingInterceptor _logger;`
`27`		`-`
`28`	`23`	`public StorageBlobTests(ITestOutputHelper output)`
	`24`	`+ : base(output)`
`29`	`25`	`{`
`30`		`- _logger = new XunitTracingInterceptor(output);`
`31`		`- XunitTracingInterceptor.AddToContext(_logger);`
`32`	`26`	`}`
`33`	`27`
`34`	`28`	`[Fact]`
`35`	`29`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`36`	`30`	`public void TestStorageBlobIsVersioningEnabled()`
`37`	`31`	`{`
`38`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobIsVersioningEnabled");`
	`32`	`+ TestRunner.RunTestScript("Test-StorageBlobIsVersioningEnabled");`
`39`	`33`	`}`
`40`	`34`
`41`	`35`	`[Fact]`
`42`	`36`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`43`	`37`	`public void TestStorageBlobContainer()`
`44`	`38`	`{`
`45`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainer");`
	`39`	`+ TestRunner.RunTestScript("Test-StorageBlobContainer");`
`46`	`40`	`}`
`47`	`41`
`48`	`42`	`[Fact]`
`49`	`43`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`50`	`44`	`public void TestStorageBlobContainerEncryptionScope()`
`51`	`45`	`{`
`52`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerEncryptionScope");`
`53`		`- }`
	`46`	`+ TestRunner.RunTestScript("Test-StorageBlobContainerEncryptionScope");`
	`47`	`+ }`
`54`	`48`
`55`	`49`	`[Fact]`
`56`	`50`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`57`	`51`	`public void TestStorageBlobContainerLegalHold()`
`58`	`52`	`{`
`59`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerLegalHold");`
	`53`	`+ TestRunner.RunTestScript("Test-StorageBlobContainerLegalHold");`
`60`	`54`	`}`
`61`	`55`
`62`	`56`	`[Fact]`
`63`	`57`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`64`	`58`	`public void TestStorageBlobContainerImmutabilityPolicy()`
`65`	`59`	`{`
`66`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerImmutabilityPolicy");`
	`60`	`+ TestRunner.RunTestScript("Test-StorageBlobContainerImmutabilityPolicy");`
`67`	`61`	`}`
`68`	`62`
`69`	`63`	`[Fact]`
`70`	`64`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`71`	`65`	`public void TestStorageBlobServiceProperties()`
`72`	`66`	`{`
`73`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobServiceProperties");`
`74`		`- }`
	`67`	`+ TestRunner.RunTestScript("Test-StorageBlobServiceProperties");`
	`68`	`+ }`
`75`	`69`
`76`	`70`	`[Fact]`
`77`	`71`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`78`	`72`	`public void TestStorageBlobORS()`
`79`	`73`	`{`
`80`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobORS");`
	`74`	`+ TestRunner.RunTestScript("Test-StorageBlobORS");`
`81`	`75`	`}`
`82`	`76`
`83`	`77`	`[Fact]`
`84`	`78`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`85`	`79`	`public void TestStorageBlobRestore()`
`86`	`80`	`{`
`87`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobRestore");`
	`81`	`+ TestRunner.RunTestScript("Test-StorageBlobRestore");`
`88`	`82`	`}`
`89`	`83`
`90`	`84`	`[Fact]`
`91`	`85`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`92`	`86`	`public void TestStorageBlobChangeFeed()`
`93`	`87`	`{`
`94`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobChangeFeed");`
	`88`	`+ TestRunner.RunTestScript("Test-StorageBlobChangeFeed");`
`95`	`89`	`}`
`96`	`90`
`97`	`91`	`[Fact]`
`98`	`92`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`99`	`93`	`public void TestStorageBlobContainerSoftDelete()`
`100`	`94`	`{`
`101`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerSoftDelete");`
	`95`	`+ TestRunner.RunTestScript("Test-StorageBlobContainerSoftDelete");`
`102`	`96`	`}`
`103`	`97`
`104`	`98`	`[Fact]`
`105`	`99`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`106`	`100`	`public void TestStorageBlobLastAccessTimeTracking()`
`107`	`101`	`{`
`108`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobLastAccessTimeTracking");`
	`102`	`+ TestRunner.RunTestScript("Test-StorageBlobLastAccessTimeTracking");`
`109`	`103`	`}`
`110`	`104`
`111`	`105`	`[Fact]`
`112`	`106`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`113`	`107`	`public void TestStorageBlobContainerVLW()`
`114`	`108`	`{`
`115`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageBlobContainerVLW");`
	`109`	`+ TestRunner.RunTestScript("Test-StorageBlobContainerVLW");`
`116`	`110`	`}`
`117`	`111`	`}`
`118`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,83 +12,72 @@`
`12`	`12`	`// limitations under the License.`
`13`	`13`	`// ----------------------------------------------------------------------------------`
`14`	`14`
`15`		`-using System;`
`16`		`-using System.Collections;`
`17`		`-using System.Collections.ObjectModel;`
`18`		`-using System.Management.Automation;`
`19`	`15`	`using Xunit;`
`20`	`16`	`using Xunit.Abstractions;`
`21`		`-using System.Diagnostics;`
`22`		`-using Microsoft.Azure.ServiceManagement.Common.Models;`
`23`	`17`	`using Microsoft.WindowsAzure.Commands.ScenarioTest;`
`24`		`-using Microsoft.WindowsAzure.Commands.Test.Utilities.Common;`
`25`		`-using Microsoft.Azure.Management.Internal.Resources;`
`26`		`-using Microsoft.Azure.Management.Storage;`
`27`	`18`	`using Microsoft.Rest.ClientRuntime.Azure.TestFramework;`
`28`	`19`
`29`	`20`	`namespace Microsoft.Azure.Commands.Management.Storage.Test.ScenarioTests`
`30`	`21`	`{`
`31`		`- public class StorageDataPlaneTests : RMTestBase`
	`22`	`+ public class StorageDataPlaneTests : StorageTestRunner`
`32`	`23`	`{`
`33`		`- public XunitTracingInterceptor _logger;`
`34`	`24`	`private string resourceGroupName;`
`35`	`25`	`private string storageAccountName;`
`36`	`26`
`37`	`27`	`public StorageDataPlaneTests(ITestOutputHelper output)`
	`28`	`+ : base(output)`
`38`	`29`	`{`
`39`	`30`	`resourceGroupName = TestUtilities.GenerateName();`
`40`	`31`	`storageAccountName = "sto" + resourceGroupName;`
`41`		`- _logger = new XunitTracingInterceptor(output);`
`42`		`- XunitTracingInterceptor.AddToContext(_logger);`
`43`	`32`	`}`
`44`	`33`
`45`	`34`	`[Fact]`
`46`	`35`	`[Trait(Category.RunType, Category.LiveOnly)]`
`47`	`36`	`public void TestBlob()`
`48`	`37`	`{`
`49`		`- TestController.NewInstance.RunPsTest(_logger, $"Test-Blob -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
	`38`	`+ TestRunner.RunTestScript($"Test-Blob -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
`50`	`39`	`}`
`51`	`40`
`52`	`41`	`[Fact]`
`53`	`42`	`[Trait(Category.RunType, Category.LiveOnly)]`
`54`	`43`	`public void TestFile()`
`55`	`44`	`{`
`56`		`- TestController.NewInstance.RunPsTest(_logger, $"Test-File -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
	`45`	`+ TestRunner.RunTestScript($"Test-File -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
`57`	`46`	`}`
`58`	`47`
`59`	`48`	`[Fact]`
`60`	`49`	`[Trait(Category.RunType, Category.LiveOnly)]`
`61`	`50`	`public void TestBlobFileCopy()`
`62`	`51`	`{`
`63`		`- TestController.NewInstance.RunPsTest(_logger, $"Test-BlobFileCopy -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
	`52`	`+ TestRunner.RunTestScript($"Test-BlobFileCopy -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
`64`	`53`	`}`
`65`	`54`
`66`	`55`	`[Fact]`
`67`	`56`	`[Trait(Category.RunType, Category.LiveOnly)]`
`68`	`57`	`public void TestTable()`
`69`	`58`	`{`
`70`		`- TestController.NewInstance.RunPsTest(_logger, $"Test-Table -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
	`59`	`+ TestRunner.RunTestScript($"Test-Table -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
`71`	`60`	`}`
`72`	`61`
`73`	`62`	`[Fact]`
`74`	`63`	`[Trait(Category.RunType, Category.LiveOnly)]`
`75`	`64`	`public void TestQueue()`
`76`	`65`	`{`
`77`		`- TestController.NewInstance.RunPsTest(_logger, $"Test-Queue -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
	`66`	`+ TestRunner.RunTestScript($"Test-Queue -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
`78`	`67`	`}`
`79`	`68`
`80`	`69`	`[Fact]`
`81`	`70`	`[Trait(Category.RunType, Category.LiveOnly)]`
`82`	`71`	`public void TestCommon()`
`83`	`72`	`{`
`84`		`- TestController.NewInstance.RunPsTest(_logger, $"Test-Common -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
	`73`	`+ TestRunner.RunTestScript($"Test-Common -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
`85`	`74`	`}`
`86`	`75`
`87`	`76`	`[Fact]`
`88`	`77`	`[Trait(Category.RunType, Category.LiveOnly)]`
`89`	`78`	`public void TestDatalakeGen2()`
`90`	`79`	`{`
`91`		`- TestController.NewInstance.RunPsTest(_logger, $"Test-DatalakeGen2 -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
	`80`	`+ TestRunner.RunTestScript($"Test-DatalakeGen2 -ResourceGroupName \"{resourceGroupName}\" -StorageAccountName \"{storageAccountName}\"");`
`92`	`81`	`}`
`93`	`82`	`}`
`94`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,65 +12,59 @@`
`12`	`12`	`// limitations under the License.`
`13`	`13`	`// ----------------------------------------------------------------------------------`
`14`	`14`
`15`		`-`
`16`		`-using Microsoft.Azure.ServiceManagement.Common.Models;`
`17`	`15`	`using Microsoft.WindowsAzure.Commands.ScenarioTest;`
`18`		`-using Microsoft.WindowsAzure.Commands.Test.Utilities.Common;`
`19`	`16`	`using Xunit;`
`20`	`17`	`using Xunit.Abstractions;`
`21`	`18`
`22`	`19`	`namespace Microsoft.Azure.Commands.Management.Storage.Test.ScenarioTests`
`23`	`20`	`{`
`24`		`- public class StorageFileTests : RMTestBase`
	`21`	`+ public class StorageFileTests : StorageTestRunner`
`25`	`22`	`{`
`26`		`- public XunitTracingInterceptor _logger;`
`27`		`-`
`28`	`23`	`public StorageFileTests(ITestOutputHelper output)`
	`24`	`+ : base(output)`
`29`	`25`	`{`
`30`		`- _logger = new XunitTracingInterceptor(output);`
`31`		`- XunitTracingInterceptor.AddToContext(_logger);`
`32`	`26`	`}`
`33`	`27`
`34`	`28`	`[Fact]`
`35`	`29`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`36`	`30`	`public void TestStorageFileShare()`
`37`	`31`	`{`
`38`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageFileShare");`
	`32`	`+ TestRunner.RunTestScript("Test-StorageFileShare");`
`39`	`33`	`}`
`40`	`34`
`41`	`35`	`[Fact]`
`42`	`36`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`43`	`37`	`public void TestStorageFileShareGetUsage()`
`44`	`38`	`{`
`45`		`- TestController.NewInstance.RunPsTest(_logger, "Test-StorageFileShareGetUsage");`
	`39`	`+ TestRunner.RunTestScript("Test-StorageFileShareGetUsage");`
`46`	`40`	`}`
`47`	`41`
`48`	`42`	`[Fact]`
`49`	`43`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`50`	`44`	`public void TestShareSoftDeletee()`
`51`	`45`	`{`
`52`		`- TestController.NewInstance.RunPsTest(_logger, "Test-ShareSoftDelete");`
	`46`	`+ TestRunner.RunTestScript("Test-ShareSoftDelete");`
`53`	`47`	`}`
`54`	`48`
`55`	`49`	`[Fact]`
`56`	`50`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`57`	`51`	`public void TestShareSnapshot()`
`58`	`52`	`{`
`59`		`- TestController.NewInstance.RunPsTest(_logger, "Test-ShareSnapshot");`
	`53`	`+ TestRunner.RunTestScript("Test-ShareSnapshot");`
`60`	`54`	`}`
`61`	`55`
`62`	`56`	`[Fact]`
`63`	`57`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`64`	`58`	`public void TestFileServiceProperties()`
`65`	`59`	`{`
`66`		`- TestController.NewInstance.RunPsTest(_logger, "Test-FileServiceProperties");`
	`60`	`+ TestRunner.RunTestScript("Test-FileServiceProperties");`
`67`	`61`	`}`
`68`	`62`
`69`	`63`	`[Fact]`
`70`	`64`	`[Trait(Category.AcceptanceType, Category.CheckIn)]`
`71`	`65`	`public void TestAzureStorageShareNFS()`
`72`	`66`	`{`
`73`		`- TestController.NewInstance.RunPsTest(_logger, "Test-AzureStorageShareNFS");`
`74`		`- }`
	`67`	`+ TestRunner.RunTestScript("Test-AzureStorageShareNFS");`
	`68`	`+ }`
`75`	`69`	`}`
`76`	`70`	`}`