Implement DoNotRunFederatedTestsAttribute to gate federated tests (#5418)

gladjohn · GladwinJohnson · web-flow · commit d31265b8225d · 2025-08-03T16:49:13.000-07:00
* fix pipeline

* Update IgnoreFederatedTests.cs

* undo

---------

Co-authored-by: Gladwin Johnson &lt;gljohns@microsoft.com&gt;
diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props
@@ -6,4 +6,7 @@
   <PropertyGroup Condition="'$(PipelineType)' == 'OneBranch'">
     <DefineConstants>$(DefineConstants);ONEBRANCH_BUILD</DefineConstants>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(MSAL_SKIP_FEDERATED_TESTS)' == 'True'">
+    <DefineConstants>$(DefineConstants);IGNORE_FEDERATED</DefineConstants>
+  </PropertyGroup>
 </Project>
diff --git a/tests/Microsoft.Identity.Test.Integration.netcore/HeadlessTests/ClientCredentialsTests.NetFwk.cs b/tests/Microsoft.Identity.Test.Integration.netcore/HeadlessTests/ClientCredentialsTests.NetFwk.cs
@@ -89,8 +89,9 @@ public async Task RefreshOnIsEnabled(bool useRegional)
 
         [DataTestMethod]
         [DataRow(Cloud.Public, TargetFrameworks.NetFx | TargetFrameworks.NetCore)]
+#if !IGNORE_FEDERATED
         [DataRow(Cloud.Adfs, TargetFrameworks.NetFx | TargetFrameworks.NetCore)]
-        //[DataRow(Cloud.PPE, TargetFrameworks.NetFx)]      
+#endif
         [DataRow(Cloud.Public, TargetFrameworks.NetCore, true)]
         //[DataRow(Cloud.Arlington)] - cert not setup
         public async Task WithCertificate_TestAsync(Cloud cloud, TargetFrameworks runOn, bool useAppIdUri = false)
@@ -101,9 +102,10 @@ public async Task WithCertificate_TestAsync(Cloud cloud, TargetFrameworks runOn,
 
         [DataTestMethod]
         [DataRow(Cloud.Public, TargetFrameworks.NetCore)]
+#if !IGNORE_FEDERATED
         [DataRow(Cloud.Adfs, TargetFrameworks.NetFx)]
+#endif
         [DataRow(Cloud.Arlington, TargetFrameworks.NetCore)]
-        //[DataRow(Cloud.PPE)] - secret not setup
         public async Task WithSecret_TestAsync(Cloud cloud, TargetFrameworks runOn)
         {
             runOn.AssertFramework();
@@ -112,8 +114,9 @@ public async Task WithSecret_TestAsync(Cloud cloud, TargetFrameworks runOn)
 
         [DataTestMethod]
         [DataRow(Cloud.Public, TargetFrameworks.NetCore)]
+#if !IGNORE_FEDERATED
         [DataRow(Cloud.Adfs, TargetFrameworks.NetCore)]
-        //[DataRow(Cloud.PPE, TargetFrameworks.NetCore)]
+#endif
         // [DataRow(Cloud.Arlington)] - cert not setup
         public async Task WithClientAssertion_Manual_TestAsync(Cloud cloud, TargetFrameworks runOn)
         {
@@ -123,8 +126,9 @@ public async Task WithClientAssertion_Manual_TestAsync(Cloud cloud, TargetFramew
 
         [DataTestMethod]
         [DataRow(Cloud.Public, TargetFrameworks.NetFx)]
+#if !IGNORE_FEDERATED
         [DataRow(Cloud.Adfs, TargetFrameworks.NetFx)]
-        //[DataRow(Cloud.PPE, TargetFrameworks.NetCore)]
+#endif
         // [DataRow(Cloud.Arlington)] - cert not setup
         public async Task WithClientAssertion_Wilson_TestAsync(Cloud cloud, TargetFrameworks runOn)
         {
@@ -143,7 +147,9 @@ public async Task WithClientClaims_ExtraClaims_TestAsync(Cloud cloud, TargetFram
 
         [DataTestMethod]
         [DataRow(Cloud.Public, TargetFrameworks.NetFx)]
+#if !IGNORE_FEDERATED
         [DataRow(Cloud.Adfs, TargetFrameworks.NetCore)]
+#endif
         // [DataRow(Cloud.Arlington)] - cert not setup
         public async Task WithClientClaims_OverrideClaims_TestAsync(Cloud cloud, TargetFrameworks runOn)
         {
@@ -162,7 +168,9 @@ public async Task WithClientClaims_SendX5C_ExtraClaims_TestAsync(Cloud cloud, Ta
 
         [DataTestMethod]
         [DataRow(Cloud.Public, TargetFrameworks.NetFx)]
+#if !IGNORE_FEDERATED
         [DataRow(Cloud.Adfs, TargetFrameworks.NetCore)]
+#endif
         // [DataRow(Cloud.Arlington)] - cert not setup
         public async Task WithClientClaims_SendX5C_OverrideClaims_TestAsync(Cloud cloud, TargetFrameworks runOn)
         {
@@ -223,12 +231,12 @@ public async Task ByRefreshTokenTestAsync()
                 .WithAuthority(labResponse.Lab.Authority, "organizations")
                 .BuildConcrete();
 
-            #pragma warning disable CS0618 // Type or member is obsolete
+#pragma warning disable CS0618 // Type or member is obsolete
             AuthenticationResult authResult = await msalPublicClient
                 .AcquireTokenByUsernamePassword(s_scopes, labResponse.User.Upn, labResponse.User.GetOrFetchPassword())
                 .ExecuteAsync(CancellationToken.None)
                 .ConfigureAwait(false);
-            #pragma warning restore CS0618
+#pragma warning restore CS0618
 
             var confidentialApp = ConfidentialClientApplicationBuilder
                 .Create(labResponse.App.AppId)
diff --git a/tests/Microsoft.Identity.Test.Integration.netcore/HeadlessTests/OnBehalfOfTests.cs b/tests/Microsoft.Identity.Test.Integration.netcore/HeadlessTests/OnBehalfOfTests.cs
@@ -226,6 +226,9 @@ public async Task OboAndClientCredentials_WithRegional_ReturnsCorrectTokens_Test
         }
 
         [TestMethod]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task WithMultipleUsers_TestAsync()
         {
             var aadUser1 = (await LabUserHelper.GetDefaultUserAsync().ConfigureAwait(false)).User;
diff --git a/tests/Microsoft.Identity.Test.Integration.netcore/HeadlessTests/UsernamePasswordIntegrationTests.NetFwk.cs b/tests/Microsoft.Identity.Test.Integration.netcore/HeadlessTests/UsernamePasswordIntegrationTests.NetFwk.cs
@@ -82,20 +82,29 @@ public async Task ARLINGTON_ROPC_AAD_CCA_Async()
 
         [RunOn(TargetFrameworks.NetCore)]
         [TestCategory(TestCategories.Arlington)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task ARLINGTON_ROPC_ADFS_Async()
         {
             var labResponse = await LabUserHelper.GetArlingtonADFSUserAsync().ConfigureAwait(false);
             await RunHappyPathTestAsync(labResponse).ConfigureAwait(false);
         }
 
         [RunOn(TargetFrameworks.NetCore)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task ROPC_ADFSv4Federated_Async()
         {
             var labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.AdfsV4, true).ConfigureAwait(false);
             await RunHappyPathTestAsync(labResponse).ConfigureAwait(false);
         }
 
         [RunOn(TargetFrameworks.NetCore)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task ROPC_ADFSv4Federated_WithMetadata_Async()
         {
             var labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.AdfsV4, true).ConfigureAwait(false);
@@ -105,6 +114,9 @@ public async Task ROPC_ADFSv4Federated_WithMetadata_Async()
 
         [RunOn(TargetFrameworks.NetCore)]
         [TestCategory(TestCategories.ADFS)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task AcquireTokenFromAdfsUsernamePasswordAsync()
         {
             LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.ADFSv2019, true).ConfigureAwait(false);
@@ -182,7 +194,7 @@ public async Task AcquireTokenWithManagedUsernameIncorrectPasswordAsync()
         }
 
         [RunOn(TargetFrameworks.NetCore)]
-        public async Task AcquireTokenWithFederatedUsernameIncorrectPasswordAsync()
+        public async Task AcquireTokenDefaultUserIncorrectPasswordAsync()
         {
             var labResponse = await LabUserHelper.GetDefaultUserAsync().ConfigureAwait(false);
             var user = labResponse.User;
@@ -475,6 +487,9 @@ public async Task Kerberos_ROPC_AAD_Async()
         }
 
         [IgnoreOnOneBranch]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task Kerberos_ROPC_ADFSv4Federated_Async()
         {
             var labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.AdfsV4, true).ConfigureAwait(false);
diff --git a/tests/Microsoft.Identity.Test.Integration.netcore/Infrastructure/IgnoreFederatedTests.cs b/tests/Microsoft.Identity.Test.Integration.netcore/Infrastructure/IgnoreFederatedTests.cs
@@ -0,0 +1,35 @@
+﻿// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.Identity.Test.Integration.Infrastructure
+{
+    /// <summary>
+    /// Ignores federated tests.
+    /// </summary>
+    internal class IgnoreFederatedTestsAttribute : TestMethodAttribute
+    {
+        public override TestResult[] Execute(ITestMethod testMethod)
+        {
+#if IGNORE_FEDERATED
+            return new[]
+            {
+                    new TestResult
+                    {
+                        Outcome = UnitTestOutcome.Inconclusive,
+                        TestFailureException = new AssertInconclusiveException(
+                            $"Skipped on OneBranch pipeline")
+                    }
+                };
+#else
+            return base.Execute(testMethod);
+#endif
+        }
+    }
+}
diff --git a/tests/Microsoft.Identity.Test.Integration.netcore/SeleniumTests/DeviceCodeFlowIntegrationTest.cs b/tests/Microsoft.Identity.Test.Integration.netcore/SeleniumTests/DeviceCodeFlowIntegrationTest.cs
@@ -65,6 +65,9 @@ public async Task ArlingtonDeviceCodeFlowTestAsync()
         [TestMethod]
         [Timeout(2 * 60 * 1000)] // 2 min timeout
         [TestCategory(TestCategories.ADFS)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task DeviceCodeFlowAdfsTestAsync()
         {
             LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.ADFSv2019, true).ConfigureAwait(false);
@@ -75,6 +78,9 @@ public async Task DeviceCodeFlowAdfsTestAsync()
         [TestMethod]
         [Timeout(2 * 60 * 1000)] // 2 min timeout
         [TestCategory(TestCategories.Arlington)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task ArlingtonDeviceCodeFlowAdfsTestAsync()
         {
             LabResponse labResponse = await LabUserHelper.GetArlingtonADFSUserAsync().ConfigureAwait(false);
diff --git a/tests/Microsoft.Identity.Test.Integration.netcore/SeleniumTests/InteractiveFlowTests.NetFwk.cs b/tests/Microsoft.Identity.Test.Integration.netcore/SeleniumTests/InteractiveFlowTests.NetFwk.cs
@@ -71,6 +71,9 @@ public async Task Interactive_MsaUser_Async()
         }
 
         [RunOn(TargetFrameworks.NetCore)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task Interactive_AdfsV4_FederatedAsync()
         {
             LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.AdfsV4, true).ConfigureAwait(false);
@@ -87,6 +90,9 @@ public async Task InteractiveConsentPromptAsync()
         }
 
         [RunOn(TargetFrameworks.NetCore)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task Interactive_AdfsV2019_FederatedAsync()
         {
             LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.ADFSv2019, true).ConfigureAwait(false);
@@ -95,6 +101,9 @@ public async Task Interactive_AdfsV2019_FederatedAsync()
 
         [RunOn(TargetFrameworks.NetCore)]
         [TestCategory(TestCategories.Arlington)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task Arlington_Interactive_AdfsV2019_FederatedAsync()
         {
             LabResponse labResponse = await LabUserHelper.GetArlingtonADFSUserAsync().ConfigureAwait(false);
@@ -156,6 +165,9 @@ public async Task Interactive_Arlington_MultiCloudSupport_AADAsync()
 
         [RunOn(TargetFrameworks.NetCore)]
         [TestCategory(TestCategories.ADFS)]
+#if IGNORE_FEDERATED
+        [Ignore]
+#endif
         public async Task Interactive_AdfsV2019_DirectAsync()
         {
             LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.ADFSv2019, true).ConfigureAwait(false);

Original file line number	Diff line number	Diff line change
`@@ -226,6 +226,9 @@ public async Task OboAndClientCredentials_WithRegional_ReturnsCorrectTokens_Test`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`[TestMethod]`
	`229`	`+#if IGNORE_FEDERATED`
	`230`	`+ [Ignore]`
	`231`	`+#endif`
`229`	`232`	`public async Task WithMultipleUsers_TestAsync()`
`230`	`233`	`{`
`231`	`234`	`var aadUser1 = (await LabUserHelper.GetDefaultUserAsync().ConfigureAwait(false)).User;`
Original file line number	Diff line number	Diff line change
`@@ -82,20 +82,29 @@ public async Task ARLINGTON_ROPC_AAD_CCA_Async()`
`82`	`82`
`83`	`83`	`[RunOn(TargetFrameworks.NetCore)]`
`84`	`84`	`[TestCategory(TestCategories.Arlington)]`
	`85`	`+#if IGNORE_FEDERATED`
	`86`	`+ [Ignore]`
	`87`	`+#endif`
`85`	`88`	`public async Task ARLINGTON_ROPC_ADFS_Async()`
`86`	`89`	`{`
`87`	`90`	`var labResponse = await LabUserHelper.GetArlingtonADFSUserAsync().ConfigureAwait(false);`
`88`	`91`	`await RunHappyPathTestAsync(labResponse).ConfigureAwait(false);`
`89`	`92`	`}`
`90`	`93`
`91`	`94`	`[RunOn(TargetFrameworks.NetCore)]`
	`95`	`+#if IGNORE_FEDERATED`
	`96`	`+ [Ignore]`
	`97`	`+#endif`
`92`	`98`	`public async Task ROPC_ADFSv4Federated_Async()`
`93`	`99`	`{`
`94`	`100`	`var labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.AdfsV4, true).ConfigureAwait(false);`
`95`	`101`	`await RunHappyPathTestAsync(labResponse).ConfigureAwait(false);`
`96`	`102`	`}`
`97`	`103`
`98`	`104`	`[RunOn(TargetFrameworks.NetCore)]`
	`105`	`+#if IGNORE_FEDERATED`
	`106`	`+ [Ignore]`
	`107`	`+#endif`
`99`	`108`	`public async Task ROPC_ADFSv4Federated_WithMetadata_Async()`
`100`	`109`	`{`
`101`	`110`	`var labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.AdfsV4, true).ConfigureAwait(false);`
`@@ -105,6 +114,9 @@ public async Task ROPC_ADFSv4Federated_WithMetadata_Async()`
`105`	`114`
`106`	`115`	`[RunOn(TargetFrameworks.NetCore)]`
`107`	`116`	`[TestCategory(TestCategories.ADFS)]`
	`117`	`+#if IGNORE_FEDERATED`
	`118`	`+ [Ignore]`
	`119`	`+#endif`
`108`	`120`	`public async Task AcquireTokenFromAdfsUsernamePasswordAsync()`
`109`	`121`	`{`
`110`	`122`	`LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.ADFSv2019, true).ConfigureAwait(false);`
`@@ -182,7 +194,7 @@ public async Task AcquireTokenWithManagedUsernameIncorrectPasswordAsync()`
`182`	`194`	`}`
`183`	`195`
`184`	`196`	`[RunOn(TargetFrameworks.NetCore)]`
`185`		`- public async Task AcquireTokenWithFederatedUsernameIncorrectPasswordAsync()`
	`197`	`+ public async Task AcquireTokenDefaultUserIncorrectPasswordAsync()`
`186`	`198`	`{`
`187`	`199`	`var labResponse = await LabUserHelper.GetDefaultUserAsync().ConfigureAwait(false);`
`188`	`200`	`var user = labResponse.User;`
`@@ -475,6 +487,9 @@ public async Task Kerberos_ROPC_AAD_Async()`
`475`	`487`	`}`
`476`	`488`
`477`	`489`	`[IgnoreOnOneBranch]`
	`490`	`+#if IGNORE_FEDERATED`
	`491`	`+ [Ignore]`
	`492`	`+#endif`
`478`	`493`	`public async Task Kerberos_ROPC_ADFSv4Federated_Async()`
`479`	`494`	`{`
`480`	`495`	`var labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.AdfsV4, true).ConfigureAwait(false);`
Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,9 @@ public async Task Interactive_MsaUser_Async()`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`[RunOn(TargetFrameworks.NetCore)]`
	`74`	`+#if IGNORE_FEDERATED`
	`75`	`+ [Ignore]`
	`76`	`+#endif`
`74`	`77`	`public async Task Interactive_AdfsV4_FederatedAsync()`
`75`	`78`	`{`
`76`	`79`	`LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.AdfsV4, true).ConfigureAwait(false);`
`@@ -87,6 +90,9 @@ public async Task InteractiveConsentPromptAsync()`
`87`	`90`	`}`
`88`	`91`
`89`	`92`	`[RunOn(TargetFrameworks.NetCore)]`
	`93`	`+#if IGNORE_FEDERATED`
	`94`	`+ [Ignore]`
	`95`	`+#endif`
`90`	`96`	`public async Task Interactive_AdfsV2019_FederatedAsync()`
`91`	`97`	`{`
`92`	`98`	`LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.ADFSv2019, true).ConfigureAwait(false);`
`@@ -95,6 +101,9 @@ public async Task Interactive_AdfsV2019_FederatedAsync()`
`95`	`101`
`96`	`102`	`[RunOn(TargetFrameworks.NetCore)]`
`97`	`103`	`[TestCategory(TestCategories.Arlington)]`
	`104`	`+#if IGNORE_FEDERATED`
	`105`	`+ [Ignore]`
	`106`	`+#endif`
`98`	`107`	`public async Task Arlington_Interactive_AdfsV2019_FederatedAsync()`
`99`	`108`	`{`
`100`	`109`	`LabResponse labResponse = await LabUserHelper.GetArlingtonADFSUserAsync().ConfigureAwait(false);`
`@@ -156,6 +165,9 @@ public async Task Interactive_Arlington_MultiCloudSupport_AADAsync()`
`156`	`165`
`157`	`166`	`[RunOn(TargetFrameworks.NetCore)]`
`158`	`167`	`[TestCategory(TestCategories.ADFS)]`
	`168`	`+#if IGNORE_FEDERATED`
	`169`	`+ [Ignore]`
	`170`	`+#endif`
`159`	`171`	`public async Task Interactive_AdfsV2019_DirectAsync()`
`160`	`172`	`{`
`161`	`173`	`LabResponse labResponse = await LabUserHelper.GetAdfsUserAsync(FederationProvider.ADFSv2019, true).ConfigureAwait(false);`