Merge pull request #703 from yoavrubin/dev

ogail · ogail · commit 1c59158c1712 · 2015-08-07T15:22:06.000-07:00
Unskipping SQL audit tests
diff --git a/src/ResourceManager/Sql/Commands.Sql.Test/ScenarioTests/DataMaskingTests.cs b/src/ResourceManager/Sql/Commands.Sql.Test/ScenarioTests/DataMaskingTests.cs
@@ -21,49 +21,49 @@ public class DataMaskingTests : SqlTestsBase
     {
 
         [Fact]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseDataMaskingPolicyEnablementToggling()
         {
             RunPowerShellTest("Test-DatabaseDataMaskingPolicyEnablementToggling");
         }
 
         [Fact]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseDataMaskingPrivilegedLoginsChanges()
         {
             RunPowerShellTest("Test-DatabaseDataMaskingPrivilegedLoginsChanges");
         }
 
         [Fact]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseDataMaskingBasicRuleLifecycle()
         {
             RunPowerShellTest("Test-DatabaseDataMaskingBasicRuleLifecycle");
         }
 
         [Fact]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseDataMaskingNumberRuleLifecycle()
         {
             RunPowerShellTest("Test-DatabaseDataMaskingNumberRuleLifecycle");
         }
 
         [Fact]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseDataMaskingTextRuleLifecycle()
         {
             RunPowerShellTest("Test-DatabaseDataMaskingTextRuleLifecycle");
         }
         
         [Fact]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseDataMaskingRuleCreationFailures()
         {
             RunPowerShellTest("Test-DatabaseDataMaskingRuleCreationFailures");
         }
 
         [Fact]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseDataMaskingRuleCreationWithoutPolicy()
         {
             RunPowerShellTest("Test-DatabaseDataMaskingRuleCreationWithoutPolicy");
diff --git a/src/ResourceManager/Sql/Commands.Sql.Test/ScenarioTests/SecurityTests.cs b/src/ResourceManager/Sql/Commands.Sql.Test/ScenarioTests/SecurityTests.cs
@@ -43,197 +43,183 @@ protected override void SetupManagementClients()
         }
 
         
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseUpdatePolicyWithStorage()
         {
             RunPowerShellTest("Test-DatabaseUpdatePolicyWithStorage");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseUpdatePolicyWithStorageV2()
         {
             RunPowerShellTest("Test-DatabaseUpdatePolicyWithStorageV2");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestServerUpdatePolicyWithStorage()
         {
             RunPowerShellTest("Test-ServerUpdatePolicyWithStorage");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseUpdatePolicyWithEventTypes()
         {
             RunPowerShellTest("Test-DatabaseUpdatePolicyWithEventTypes");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestServerUpdatePolicyWithEventTypes()
         {
             RunPowerShellTest("Test-ServerUpdatePolicyWithEventTypes");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDisableDatabaseAuditing()
         {
             RunPowerShellTest("Test-DisableDatabaseAuditing");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDisableServerAuditing()
         {
             RunPowerShellTest("Test-DisableServerAuditing");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseDisableEnableKeepProperties()
         {
             RunPowerShellTest("Test-DatabaseDisableEnableKeepProperties");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestServerDisableEnableKeepProperties()
         {
             RunPowerShellTest("Test-ServerDisableEnableKeepProperties");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestUseServerDefault()
         {
             RunPowerShellTest("Test-UseServerDefault");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestFailedDatabaseUpdatePolicyWithNoStorage()
         {
             RunPowerShellTest("Test-FailedDatabaseUpdatePolicyWithNoStorage");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestFailedServerUpdatePolicyWithNoStorage()
         {
             RunPowerShellTest("Test-FailedServerUpdatePolicyWithNoStorage");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestFailedUseServerDefault()
         {
             RunPowerShellTest("Test-FailedUseServerDefault");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseUpdatePolicyWithEventTypeShortcuts()
         {
             RunPowerShellTest("Test-DatabaseUpdatePolicyWithEventTypeShortcuts");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestServerUpdatePolicyWithEventTypeShortcuts()
         {
             RunPowerShellTest("Test-ServerUpdatePolicyWithEventTypeShortcuts");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseUpdatePolicyKeepPreviousStorage()
         {
             RunPowerShellTest("Test-DatabaseUpdatePolicyKeepPreviousStorage");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestServerUpdatePolicyKeepPreviousStorage()
         {
             RunPowerShellTest("Test-ServerUpdatePolicyKeepPreviousStorage");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestFailWithBadDatabaseIndentity()
         {
             RunPowerShellTest("Test-FailWithBadDatabaseIndentity");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestFailWithBadServerIndentity()
         {
             RunPowerShellTest("Test-FailWithBadServerIndentity");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseStorageKeyRotation()
         {
             RunPowerShellTest("Test-DatabaseStorageKeyRotation");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
-        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestServerStorageKeyRotation()
         {
             RunPowerShellTest("Test-ServerStorageKeyRotation");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestServerUpdatePolicyWithRetention()
         {
             RunPowerShellTest("Test-ServerUpdatePolicyWithRetention");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseUpdatePolicyWithRetention()
         {
             RunPowerShellTest("Test-DatabaseUpdatePolicyWithRetention");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestServerRetentionKeepProperties()
         {
             RunPowerShellTest("Test-ServerRetentionKeepProperties");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseRetentionKeepProperties()
         {
             RunPowerShellTest("Test-DatabaseRetentionKeepProperties");
         }
 
-        [Fact(Skip = "Skip for the version header upgrade on Storage library.")]
-        [Trait(Category.RunType, Category.LiveOnly)]
+        [Fact]
+        [Trait(Category.Sql, Category.CheckIn)]
         public void TestDatabaseUpdatePolicyWithSameNameStorageOnDifferentRegion()
         {
             RunPowerShellTest("Test-DatabaseUpdatePolicyWithSameNameStorageOnDifferentRegion");
diff --git a/src/ResourceManager/Sql/Commands.Sql.Test/SessionRecords/Microsoft.Azure.Commands.ScenarioTest.SqlTests.SecurityTests/TestDatabaseUpdatePolicyWithStorageV2.json b/src/ResourceManager/Sql/Commands.Sql.Test/SessionRecords/Microsoft.Azure.Commands.ScenarioTest.SqlTests.SecurityTests/TestDatabaseUpdatePolicyWithStorageV2.json

Original file line number	Diff line number	Diff line change
`@@ -21,49 +21,49 @@ public class DataMaskingTests : SqlTestsBase`
`21`	`21`	`{`
`22`	`22`
`23`	`23`	`[Fact]`
`24`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`24`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`25`	`25`	`public void TestDatabaseDataMaskingPolicyEnablementToggling()`
`26`	`26`	`{`
`27`	`27`	`RunPowerShellTest("Test-DatabaseDataMaskingPolicyEnablementToggling");`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`[Fact]`
`31`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`31`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`32`	`32`	`public void TestDatabaseDataMaskingPrivilegedLoginsChanges()`
`33`	`33`	`{`
`34`	`34`	`RunPowerShellTest("Test-DatabaseDataMaskingPrivilegedLoginsChanges");`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`[Fact]`
`38`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`38`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`39`	`39`	`public void TestDatabaseDataMaskingBasicRuleLifecycle()`
`40`	`40`	`{`
`41`	`41`	`RunPowerShellTest("Test-DatabaseDataMaskingBasicRuleLifecycle");`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`[Fact]`
`45`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`45`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`46`	`46`	`public void TestDatabaseDataMaskingNumberRuleLifecycle()`
`47`	`47`	`{`
`48`	`48`	`RunPowerShellTest("Test-DatabaseDataMaskingNumberRuleLifecycle");`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`[Fact]`
`52`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`52`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`53`	`53`	`public void TestDatabaseDataMaskingTextRuleLifecycle()`
`54`	`54`	`{`
`55`	`55`	`RunPowerShellTest("Test-DatabaseDataMaskingTextRuleLifecycle");`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`[Fact]`
`59`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`59`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`60`	`60`	`public void TestDatabaseDataMaskingRuleCreationFailures()`
`61`	`61`	`{`
`62`	`62`	`RunPowerShellTest("Test-DatabaseDataMaskingRuleCreationFailures");`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`[Fact]`
`66`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`66`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`67`	`67`	`public void TestDatabaseDataMaskingRuleCreationWithoutPolicy()`
`68`	`68`	`{`
`69`	`69`	`RunPowerShellTest("Test-DatabaseDataMaskingRuleCreationWithoutPolicy");`
Original file line number	Diff line number	Diff line change
`@@ -43,197 +43,183 @@ protected override void SetupManagementClients()`
`43`	`43`	`}`
`44`	`44`
`45`	`45`
`46`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`47`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`46`	`+ [Fact]`
	`47`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`48`	`48`	`public void TestDatabaseUpdatePolicyWithStorage()`
`49`	`49`	`{`
`50`	`50`	`RunPowerShellTest("Test-DatabaseUpdatePolicyWithStorage");`
`51`	`51`	`}`
`52`	`52`
`53`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`54`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`53`	`+ [Fact]`
	`54`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`55`	`55`	`public void TestDatabaseUpdatePolicyWithStorageV2()`
`56`	`56`	`{`
`57`	`57`	`RunPowerShellTest("Test-DatabaseUpdatePolicyWithStorageV2");`
`58`	`58`	`}`
`59`	`59`
`60`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`61`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`60`	`+ [Fact]`
	`61`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`62`	`62`	`public void TestServerUpdatePolicyWithStorage()`
`63`	`63`	`{`
`64`	`64`	`RunPowerShellTest("Test-ServerUpdatePolicyWithStorage");`
`65`	`65`	`}`
`66`	`66`
`67`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
	`67`	`+ [Fact]`
	`68`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`68`	`69`	`public void TestDatabaseUpdatePolicyWithEventTypes()`
`69`	`70`	`{`
`70`	`71`	`RunPowerShellTest("Test-DatabaseUpdatePolicyWithEventTypes");`
`71`	`72`	`}`
`72`	`73`
`73`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`74`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`74`	`+ [Fact]`
	`75`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`75`	`76`	`public void TestServerUpdatePolicyWithEventTypes()`
`76`	`77`	`{`
`77`	`78`	`RunPowerShellTest("Test-ServerUpdatePolicyWithEventTypes");`
`78`	`79`	`}`
`79`	`80`
`80`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`81`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`82`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`81`	`+ [Fact]`
	`82`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`83`	`83`	`public void TestDisableDatabaseAuditing()`
`84`	`84`	`{`
`85`	`85`	`RunPowerShellTest("Test-DisableDatabaseAuditing");`
`86`	`86`	`}`
`87`	`87`
`88`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`89`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`90`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`88`	`+ [Fact]`
	`89`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`91`	`90`	`public void TestDisableServerAuditing()`
`92`	`91`	`{`
`93`	`92`	`RunPowerShellTest("Test-DisableServerAuditing");`
`94`	`93`	`}`
`95`	`94`
`96`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`97`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`98`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`95`	`+ [Fact]`
	`96`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`99`	`97`	`public void TestDatabaseDisableEnableKeepProperties()`
`100`	`98`	`{`
`101`	`99`	`RunPowerShellTest("Test-DatabaseDisableEnableKeepProperties");`
`102`	`100`	`}`
`103`	`101`
`104`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`105`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`106`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`102`	`+ [Fact]`
	`103`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`107`	`104`	`public void TestServerDisableEnableKeepProperties()`
`108`	`105`	`{`
`109`	`106`	`RunPowerShellTest("Test-ServerDisableEnableKeepProperties");`
`110`	`107`	`}`
`111`	`108`
`112`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`113`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`114`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`109`	`+ [Fact]`
	`110`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`115`	`111`	`public void TestUseServerDefault()`
`116`	`112`	`{`
`117`	`113`	`RunPowerShellTest("Test-UseServerDefault");`
`118`	`114`	`}`
`119`	`115`
`120`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`121`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`116`	`+ [Fact]`
	`117`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`122`	`118`	`public void TestFailedDatabaseUpdatePolicyWithNoStorage()`
`123`	`119`	`{`
`124`	`120`	`RunPowerShellTest("Test-FailedDatabaseUpdatePolicyWithNoStorage");`
`125`	`121`	`}`
`126`	`122`
`127`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`128`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`129`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`123`	`+ [Fact]`
	`124`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`130`	`125`	`public void TestFailedServerUpdatePolicyWithNoStorage()`
`131`	`126`	`{`
`132`	`127`	`RunPowerShellTest("Test-FailedServerUpdatePolicyWithNoStorage");`
`133`	`128`	`}`
`134`	`129`
`135`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`136`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`137`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`130`	`+ [Fact]`
	`131`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`138`	`132`	`public void TestFailedUseServerDefault()`
`139`	`133`	`{`
`140`	`134`	`RunPowerShellTest("Test-FailedUseServerDefault");`
`141`	`135`	`}`
`142`	`136`
`143`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`144`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`145`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`137`	`+ [Fact]`
	`138`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`146`	`139`	`public void TestDatabaseUpdatePolicyWithEventTypeShortcuts()`
`147`	`140`	`{`
`148`	`141`	`RunPowerShellTest("Test-DatabaseUpdatePolicyWithEventTypeShortcuts");`
`149`	`142`	`}`
`150`	`143`
`151`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`152`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`153`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`144`	`+ [Fact]`
	`145`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`154`	`146`	`public void TestServerUpdatePolicyWithEventTypeShortcuts()`
`155`	`147`	`{`
`156`	`148`	`RunPowerShellTest("Test-ServerUpdatePolicyWithEventTypeShortcuts");`
`157`	`149`	`}`
`158`	`150`
`159`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`160`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`161`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`151`	`+ [Fact]`
	`152`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`162`	`153`	`public void TestDatabaseUpdatePolicyKeepPreviousStorage()`
`163`	`154`	`{`
`164`	`155`	`RunPowerShellTest("Test-DatabaseUpdatePolicyKeepPreviousStorage");`
`165`	`156`	`}`
`166`	`157`
`167`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`168`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`169`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`158`	`+ [Fact]`
	`159`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`170`	`160`	`public void TestServerUpdatePolicyKeepPreviousStorage()`
`171`	`161`	`{`
`172`	`162`	`RunPowerShellTest("Test-ServerUpdatePolicyKeepPreviousStorage");`
`173`	`163`	`}`
`174`	`164`
`175`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`176`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`177`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`165`	`+ [Fact]`
	`166`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`178`	`167`	`public void TestFailWithBadDatabaseIndentity()`
`179`	`168`	`{`
`180`	`169`	`RunPowerShellTest("Test-FailWithBadDatabaseIndentity");`
`181`	`170`	`}`
`182`	`171`
`183`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`184`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`185`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`172`	`+ [Fact]`
	`173`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`186`	`174`	`public void TestFailWithBadServerIndentity()`
`187`	`175`	`{`
`188`	`176`	`RunPowerShellTest("Test-FailWithBadServerIndentity");`
`189`	`177`	`}`
`190`	`178`
`191`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`192`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`193`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`179`	`+ [Fact]`
	`180`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`194`	`181`	`public void TestDatabaseStorageKeyRotation()`
`195`	`182`	`{`
`196`	`183`	`RunPowerShellTest("Test-DatabaseStorageKeyRotation");`
`197`	`184`	`}`
`198`	`185`
`199`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`200`		`- [Trait(Category.RunType, Category.LiveOnly)]`
`201`		`- [Trait(Category.AcceptanceType, Category.CheckIn)]`
	`186`	`+ [Fact]`
	`187`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`202`	`188`	`public void TestServerStorageKeyRotation()`
`203`	`189`	`{`
`204`	`190`	`RunPowerShellTest("Test-ServerStorageKeyRotation");`
`205`	`191`	`}`
`206`	`192`
`207`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`208`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`193`	`+ [Fact]`
	`194`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`209`	`195`	`public void TestServerUpdatePolicyWithRetention()`
`210`	`196`	`{`
`211`	`197`	`RunPowerShellTest("Test-ServerUpdatePolicyWithRetention");`
`212`	`198`	`}`
`213`	`199`
`214`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`215`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`200`	`+ [Fact]`
	`201`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`216`	`202`	`public void TestDatabaseUpdatePolicyWithRetention()`
`217`	`203`	`{`
`218`	`204`	`RunPowerShellTest("Test-DatabaseUpdatePolicyWithRetention");`
`219`	`205`	`}`
`220`	`206`
`221`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`222`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`207`	`+ [Fact]`
	`208`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`223`	`209`	`public void TestServerRetentionKeepProperties()`
`224`	`210`	`{`
`225`	`211`	`RunPowerShellTest("Test-ServerRetentionKeepProperties");`
`226`	`212`	`}`
`227`	`213`
`228`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`229`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`214`	`+ [Fact]`
	`215`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`230`	`216`	`public void TestDatabaseRetentionKeepProperties()`
`231`	`217`	`{`
`232`	`218`	`RunPowerShellTest("Test-DatabaseRetentionKeepProperties");`
`233`	`219`	`}`
`234`	`220`
`235`		`- [Fact(Skip = "Skip for the version header upgrade on Storage library.")]`
`236`		`- [Trait(Category.RunType, Category.LiveOnly)]`
	`221`	`+ [Fact]`
	`222`	`+ [Trait(Category.Sql, Category.CheckIn)]`
`237`	`223`	`public void TestDatabaseUpdatePolicyWithSameNameStorageOnDifferentRegion()`
`238`	`224`	`{`
`239`	`225`	`RunPowerShellTest("Test-DatabaseUpdatePolicyWithSameNameStorageOnDifferentRegion");`