fix: Added fix for failed test cases

OMpawar-21 · OMpawar-21 · commit 26ada7eaef7b · 2026-04-29T10:50:50.000+05:30
diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack011_GlobalFieldTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack011_GlobalFieldTest.cs
@@ -689,7 +689,7 @@ public void Test029_Should_Fail_Fetch_With_Empty_UID()
         {
             TestOutputLogger.LogContext("TestScenario", "FetchGlobalField_EmptyUID");
             
-            AssertLogger.ThrowsException<InvalidOperationException>(
+            AssertLogger.ThrowsException<ArgumentException>(
                 () => _stack.GlobalField("").Fetch(),
                 "FetchEmptyUID");
         }
@@ -700,7 +700,7 @@ public void Test030_Should_Fail_Update_With_Empty_UID()
         {
             TestOutputLogger.LogContext("TestScenario", "UpdateGlobalField_EmptyUID");
             
-            AssertLogger.ThrowsException<InvalidOperationException>(
+            AssertLogger.ThrowsException<ArgumentException>(
                 () => _stack.GlobalField("").Update(_modelling),
                 "UpdateEmptyUID");
         }
@@ -711,7 +711,7 @@ public void Test031_Should_Fail_Delete_With_Empty_UID()
         {
             TestOutputLogger.LogContext("TestScenario", "DeleteGlobalField_EmptyUID");
             
-            AssertLogger.ThrowsException<InvalidOperationException>(
+            AssertLogger.ThrowsException<ArgumentException>(
                 () => _stack.GlobalField("").Delete(),
                 "DeleteEmptyUID");
         }
@@ -871,9 +871,9 @@ public async System.Threading.Tasks.Task Test042_Should_Fail_Fetch_Async_With_Em
             try
             {
                 await _stack.GlobalField("").FetchAsync();
-                AssertLogger.Fail("Expected InvalidOperationException for empty UID");
+                AssertLogger.Fail("Expected ArgumentException for empty UID");
             }
-            catch (InvalidOperationException)
+            catch (ArgumentException)
             {
                 // Expected exception - test passes
             }
@@ -888,9 +888,9 @@ public async System.Threading.Tasks.Task Test043_Should_Fail_Update_Async_With_E
             try
             {
                 await _stack.GlobalField("").UpdateAsync(_modelling);
-                AssertLogger.Fail("Expected InvalidOperationException for empty UID");
+                AssertLogger.Fail("Expected ArgumentException for empty UID");
             }
-            catch (InvalidOperationException)
+            catch (ArgumentException)
             {
                 // Expected exception - test passes
             }
@@ -905,9 +905,9 @@ public async System.Threading.Tasks.Task Test044_Should_Fail_Delete_Async_With_E
             try
             {
                 await _stack.GlobalField("").DeleteAsync();
-                AssertLogger.Fail("Expected InvalidOperationException for empty UID");
+                AssertLogger.Fail("Expected ArgumentException for empty UID");
             }
-            catch (InvalidOperationException)
+            catch (ArgumentException)
             {
                 // Expected exception - test passes
             }
diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_ContentTypeTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_ContentTypeTest.cs
@@ -244,7 +244,7 @@ public void Test012_Should_Throw_When_Fetch_Without_UID()
         {
             TestOutputLogger.LogContext("TestScenario", "FetchContentType_NoUID");
             
-            AssertLogger.ThrowsException<InvalidOperationException>(
+            AssertLogger.ThrowsException<ArgumentException>(
                 () => _stack.ContentType().Fetch(),
                 "Fetch_NoUID");
         }
@@ -255,7 +255,7 @@ public async Task Test013_Should_Throw_When_FetchAsync_Without_UID()
         {
             TestOutputLogger.LogContext("TestScenario", "FetchAsyncContentType_NoUID");
 
-            await AssertLogger.ThrowsExceptionAsync<InvalidOperationException>(
+            await AssertLogger.ThrowsExceptionAsync<ArgumentException>(
                 () => _stack.ContentType().FetchAsync(),
                 "FetchAsync_NoUID");
         }
@@ -268,7 +268,7 @@ public void Test014_Should_Throw_When_Update_Without_UID()
 
             var model = CreateValidContentTypeModel("update_no_uid");
             
-            AssertLogger.ThrowsException<InvalidOperationException>(
+            AssertLogger.ThrowsException<ArgumentException>(
                 () => _stack.ContentType().Update(model),
                 "Update_NoUID");
         }
@@ -290,7 +290,7 @@ public void Test016_Should_Throw_When_Delete_Without_UID()
         {
             TestOutputLogger.LogContext("TestScenario", "DeleteContentType_NoUID");
             
-            AssertLogger.ThrowsException<InvalidOperationException>(
+            AssertLogger.ThrowsException<ArgumentException>(
                 () => _stack.ContentType().Delete(),
                 "Delete_NoUID");
         }
diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs
@@ -1317,9 +1317,9 @@ public void Test028_Should_Fail_Fetch_With_Empty_UID()
         {
             TestOutputLogger.LogContext("TestScenario", "FetchNestedGlobalField_EmptyUID");
 
-            Assert.ThrowsException<InvalidOperationException>(
+            Assert.ThrowsException<ArgumentException>(
                 () => _stack.GlobalField("").Fetch(),
-                "Expected InvalidOperationException for empty UID");
+                "Expected ArgumentException for empty UID");
         }
 
         [TestMethod]
@@ -1329,9 +1329,9 @@ public void Test029_Should_Fail_Update_With_Empty_UID()
             TestOutputLogger.LogContext("TestScenario", "UpdateNestedGlobalField_EmptyUID");
             var updateModel = CreateNestedGlobalFieldModel();
 
-            Assert.ThrowsException<InvalidOperationException>(
+            Assert.ThrowsException<ArgumentException>(
                 () => _stack.GlobalField("").Update(updateModel),
-                "Expected InvalidOperationException for empty UID");
+                "Expected ArgumentException for empty UID");
         }
 
         [TestMethod]
@@ -1340,9 +1340,9 @@ public void Test030_Should_Fail_Delete_With_Empty_UID()
         {
             TestOutputLogger.LogContext("TestScenario", "DeleteNestedGlobalField_EmptyUID");
 
-            Assert.ThrowsException<InvalidOperationException>(
+            Assert.ThrowsException<ArgumentException>(
                 () => _stack.GlobalField("").Delete(),
-                "Expected InvalidOperationException for empty UID");
+                "Expected ArgumentException for empty UID");
         }
 
         [TestMethod]
@@ -1468,9 +1468,9 @@ public async Task Test038_Should_Fail_Fetch_Async_With_Empty_UID()
             try
             {
                 await _stack.GlobalField("").FetchAsync();
-                Assert.Fail("Expected InvalidOperationException for empty UID");
+                Assert.Fail("Expected ArgumentException for empty UID");
             }
-            catch (InvalidOperationException)
+            catch (ArgumentException)
             {
                 // Expected exception - test passes
             }
@@ -1485,9 +1485,9 @@ public async Task Test039_Should_Fail_Delete_Async_With_Empty_UID()
             try
             {
                 await _stack.GlobalField("").DeleteAsync();
-                Assert.Fail("Expected InvalidOperationException for empty UID");
+                Assert.Fail("Expected ArgumentException for empty UID");
             }
-            catch (InvalidOperationException)
+            catch (ArgumentException)
             {
                 // Expected exception - test passes
             }
diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack014_EntryTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack014_EntryTest.cs
@@ -97,9 +97,10 @@ private static void AssertAuthenticationError(Exception ex, string assertionName
                 AssertLogger.IsTrue(
                     cex.StatusCode == HttpStatusCode.Unauthorized || 
                     cex.StatusCode == HttpStatusCode.Forbidden ||
+                    cex.StatusCode == HttpStatusCode.BadRequest || // API returns 400 for malformed tokens
                     cex.StatusCode == HttpStatusCode.PreconditionFailed ||
                     cex.StatusCode == (HttpStatusCode)422, // API treats not found as auth failure
-                    $"Expected 401/403/412/422 for auth error, got {(int)cex.StatusCode} ({cex.StatusCode})",
+                    $"Expected 400/401/403/412/422 for auth error, got {(int)cex.StatusCode} ({cex.StatusCode})",
                     assertionName);
             }
             else if (ex is InvalidOperationException && ex.Message.Contains("not logged in"))
diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack018_EnvironmentTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack018_EnvironmentTest.cs
@@ -1013,7 +1013,7 @@ await AssertLogger.ThrowsContentstackErrorAsync(
         public void Test044_Should_Fail_With_Null_Environment_UID_Sync()
         {
             TestOutputLogger.LogContext("TestScenario", "Test044_Should_Fail_With_Null_Environment_UID_Sync");
-            AssertLogger.ThrowsException<InvalidOperationException>(
+            AssertLogger.ThrowsException<ArgumentException>(
                 () => _stack.Environment(null).Fetch(),
                 "FetchNullUidSync");
         }
@@ -1022,7 +1022,7 @@ public void Test044_Should_Fail_With_Null_Environment_UID_Sync()
         public void Test045_Should_Fail_With_Empty_Environment_UID_Sync()
         {
             TestOutputLogger.LogContext("TestScenario", "Test045_Should_Fail_With_Empty_Environment_UID_Sync");
-            AssertLogger.ThrowsException<InvalidOperationException>(
+            AssertLogger.ThrowsException<ArgumentException>(
                 () => _stack.Environment("").Fetch(),
                 "FetchEmptyUidSync");
         }
@@ -1123,15 +1123,15 @@ public async Task Test050_Should_Fail_With_Null_Environment_UID_Async()
         try
         {
             await _stack.Environment(null).FetchAsync();
-            AssertLogger.Fail("Expected InvalidOperationException for null UID");
+            AssertLogger.Fail("Expected ArgumentException for null UID");
         }
-        catch (InvalidOperationException)
+        catch (ArgumentException)
         {
-            AssertLogger.IsTrue(true, "InvalidOperationException thrown as expected", "FetchNullUidAsync");
+            AssertLogger.IsTrue(true, "ArgumentException thrown as expected", "FetchNullUidAsync");
         }
         catch (Exception ex)
         {
-            AssertLogger.Fail($"Expected InvalidOperationException but got {ex.GetType().Name}");
+            AssertLogger.Fail($"Expected ArgumentException but got {ex.GetType().Name}");
         }
         }
 
@@ -1142,15 +1142,15 @@ public async Task Test051_Should_Fail_With_Empty_Environment_UID_Async()
             try
             {
                 await _stack.Environment("").FetchAsync();
-                AssertLogger.Fail("Expected InvalidOperationException for empty UID");
+                AssertLogger.Fail("Expected ArgumentException for empty UID");
             }
-            catch (InvalidOperationException)
+            catch (ArgumentException)
             {
-                AssertLogger.IsTrue(true, "InvalidOperationException thrown as expected", "FetchEmptyUidAsync");
+                AssertLogger.IsTrue(true, "ArgumentException thrown as expected", "FetchEmptyUidAsync");
             }
             catch (Exception ex)
             {
-                AssertLogger.Fail($"Expected InvalidOperationException but got {ex.GetType().Name}");
+                AssertLogger.Fail($"Expected ArgumentException but got {ex.GetType().Name}");
             }
         }
 
diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack020_WorkflowTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack020_WorkflowTest.cs
@@ -3151,7 +3151,7 @@ public void Test141_Should_Fail_With_Null_Workflow_UID_Parameter()
             try
             {
                 // Act & Assert - SDK should validate UID before API call
-                AssertLogger.ThrowsException<InvalidOperationException>(() =>
+                AssertLogger.ThrowsException<ArgumentException>(() =>
                 {
                     _stack.Workflow(null).Fetch();
                 }, "fetchWorkflowNullUID");
@@ -3160,7 +3160,7 @@ public void Test141_Should_Fail_With_Null_Workflow_UID_Parameter()
             }
             catch (Exception ex)
             {
-                FailWithError("Expected InvalidOperationException for null workflow UID", ex);
+                FailWithError("Expected ArgumentException for null workflow UID", ex);
             }
         }
 
@@ -3172,7 +3172,7 @@ public void Test142_Should_Fail_With_Empty_Workflow_UID_Parameter()
             try
             {
                 // Act & Assert - SDK should validate UID before API call
-                AssertLogger.ThrowsException<InvalidOperationException>(() =>
+                AssertLogger.ThrowsException<ArgumentException>(() =>
                 {
                     _stack.Workflow("").Fetch();
                 }, "fetchWorkflowEmptyUID");
@@ -3181,7 +3181,7 @@ public void Test142_Should_Fail_With_Empty_Workflow_UID_Parameter()
             }
             catch (Exception ex)
             {
-                FailWithError("Expected InvalidOperationException for empty workflow UID", ex);
+                FailWithError("Expected ArgumentException for empty workflow UID", ex);
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -689,7 +689,7 @@ public void Test029_Should_Fail_Fetch_With_Empty_UID()`
`689`	`689`	`{`
`690`	`690`	`TestOutputLogger.LogContext("TestScenario", "FetchGlobalField_EmptyUID");`
`691`	`691`
`692`		`- AssertLogger.ThrowsException<InvalidOperationException>(`
	`692`	`+ AssertLogger.ThrowsException<ArgumentException>(`
`693`	`693`	`() => _stack.GlobalField("").Fetch(),`
`694`	`694`	`"FetchEmptyUID");`
`695`	`695`	`}`
`@@ -700,7 +700,7 @@ public void Test030_Should_Fail_Update_With_Empty_UID()`
`700`	`700`	`{`
`701`	`701`	`TestOutputLogger.LogContext("TestScenario", "UpdateGlobalField_EmptyUID");`
`702`	`702`
`703`		`- AssertLogger.ThrowsException<InvalidOperationException>(`
	`703`	`+ AssertLogger.ThrowsException<ArgumentException>(`
`704`	`704`	`() => _stack.GlobalField("").Update(_modelling),`
`705`	`705`	`"UpdateEmptyUID");`
`706`	`706`	`}`
`@@ -711,7 +711,7 @@ public void Test031_Should_Fail_Delete_With_Empty_UID()`
`711`	`711`	`{`
`712`	`712`	`TestOutputLogger.LogContext("TestScenario", "DeleteGlobalField_EmptyUID");`
`713`	`713`
`714`		`- AssertLogger.ThrowsException<InvalidOperationException>(`
	`714`	`+ AssertLogger.ThrowsException<ArgumentException>(`
`715`	`715`	`() => _stack.GlobalField("").Delete(),`
`716`	`716`	`"DeleteEmptyUID");`
`717`	`717`	`}`
`@@ -871,9 +871,9 @@ public async System.Threading.Tasks.Task Test042_Should_Fail_Fetch_Async_With_Em`
`871`	`871`	`try`
`872`	`872`	`{`
`873`	`873`	`await _stack.GlobalField("").FetchAsync();`
`874`		`- AssertLogger.Fail("Expected InvalidOperationException for empty UID");`
	`874`	`+ AssertLogger.Fail("Expected ArgumentException for empty UID");`
`875`	`875`	`}`
`876`		`- catch (InvalidOperationException)`
	`876`	`+ catch (ArgumentException)`
`877`	`877`	`{`
`878`	`878`	`// Expected exception - test passes`
`879`	`879`	`}`
`@@ -888,9 +888,9 @@ public async System.Threading.Tasks.Task Test043_Should_Fail_Update_Async_With_E`
`888`	`888`	`try`
`889`	`889`	`{`
`890`	`890`	`await _stack.GlobalField("").UpdateAsync(_modelling);`
`891`		`- AssertLogger.Fail("Expected InvalidOperationException for empty UID");`
	`891`	`+ AssertLogger.Fail("Expected ArgumentException for empty UID");`
`892`	`892`	`}`
`893`		`- catch (InvalidOperationException)`
	`893`	`+ catch (ArgumentException)`
`894`	`894`	`{`
`895`	`895`	`// Expected exception - test passes`
`896`	`896`	`}`
`@@ -905,9 +905,9 @@ public async System.Threading.Tasks.Task Test044_Should_Fail_Delete_Async_With_E`
`905`	`905`	`try`
`906`	`906`	`{`
`907`	`907`	`await _stack.GlobalField("").DeleteAsync();`
`908`		`- AssertLogger.Fail("Expected InvalidOperationException for empty UID");`
	`908`	`+ AssertLogger.Fail("Expected ArgumentException for empty UID");`
`909`	`909`	`}`
`910`		`- catch (InvalidOperationException)`
	`910`	`+ catch (ArgumentException)`
`911`	`911`	`{`
`912`	`912`	`// Expected exception - test passes`
`913`	`913`	`}`
Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ public void Test012_Should_Throw_When_Fetch_Without_UID()`
`244`	`244`	`{`
`245`	`245`	`TestOutputLogger.LogContext("TestScenario", "FetchContentType_NoUID");`
`246`	`246`
`247`		`- AssertLogger.ThrowsException<InvalidOperationException>(`
	`247`	`+ AssertLogger.ThrowsException<ArgumentException>(`
`248`	`248`	`() => _stack.ContentType().Fetch(),`
`249`	`249`	`"Fetch_NoUID");`
`250`	`250`	`}`
`@@ -255,7 +255,7 @@ public async Task Test013_Should_Throw_When_FetchAsync_Without_UID()`
`255`	`255`	`{`
`256`	`256`	`TestOutputLogger.LogContext("TestScenario", "FetchAsyncContentType_NoUID");`
`257`	`257`
`258`		`- await AssertLogger.ThrowsExceptionAsync<InvalidOperationException>(`
	`258`	`+ await AssertLogger.ThrowsExceptionAsync<ArgumentException>(`
`259`	`259`	`() => _stack.ContentType().FetchAsync(),`
`260`	`260`	`"FetchAsync_NoUID");`
`261`	`261`	`}`
`@@ -268,7 +268,7 @@ public void Test014_Should_Throw_When_Update_Without_UID()`
`268`	`268`
`269`	`269`	`var model = CreateValidContentTypeModel("update_no_uid");`
`270`	`270`
`271`		`- AssertLogger.ThrowsException<InvalidOperationException>(`
	`271`	`+ AssertLogger.ThrowsException<ArgumentException>(`
`272`	`272`	`() => _stack.ContentType().Update(model),`
`273`	`273`	`"Update_NoUID");`
`274`	`274`	`}`
`@@ -290,7 +290,7 @@ public void Test016_Should_Throw_When_Delete_Without_UID()`
`290`	`290`	`{`
`291`	`291`	`TestOutputLogger.LogContext("TestScenario", "DeleteContentType_NoUID");`
`292`	`292`
`293`		`- AssertLogger.ThrowsException<InvalidOperationException>(`
	`293`	`+ AssertLogger.ThrowsException<ArgumentException>(`
`294`	`294`	`() => _stack.ContentType().Delete(),`
`295`	`295`	`"Delete_NoUID");`
`296`	`296`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1317,9 +1317,9 @@ public void Test028_Should_Fail_Fetch_With_Empty_UID()`
`1317`	`1317`	`{`
`1318`	`1318`	`TestOutputLogger.LogContext("TestScenario", "FetchNestedGlobalField_EmptyUID");`
`1319`	`1319`
`1320`		`- Assert.ThrowsException<InvalidOperationException>(`
	`1320`	`+ Assert.ThrowsException<ArgumentException>(`
`1321`	`1321`	`() => _stack.GlobalField("").Fetch(),`
`1322`		`- "Expected InvalidOperationException for empty UID");`
	`1322`	`+ "Expected ArgumentException for empty UID");`
`1323`	`1323`	`}`
`1324`	`1324`
`1325`	`1325`	`[TestMethod]`
`@@ -1329,9 +1329,9 @@ public void Test029_Should_Fail_Update_With_Empty_UID()`
`1329`	`1329`	`TestOutputLogger.LogContext("TestScenario", "UpdateNestedGlobalField_EmptyUID");`
`1330`	`1330`	`var updateModel = CreateNestedGlobalFieldModel();`
`1331`	`1331`
`1332`		`- Assert.ThrowsException<InvalidOperationException>(`
	`1332`	`+ Assert.ThrowsException<ArgumentException>(`
`1333`	`1333`	`() => _stack.GlobalField("").Update(updateModel),`
`1334`		`- "Expected InvalidOperationException for empty UID");`
	`1334`	`+ "Expected ArgumentException for empty UID");`
`1335`	`1335`	`}`
`1336`	`1336`
`1337`	`1337`	`[TestMethod]`
`@@ -1340,9 +1340,9 @@ public void Test030_Should_Fail_Delete_With_Empty_UID()`
`1340`	`1340`	`{`
`1341`	`1341`	`TestOutputLogger.LogContext("TestScenario", "DeleteNestedGlobalField_EmptyUID");`
`1342`	`1342`
`1343`		`- Assert.ThrowsException<InvalidOperationException>(`
	`1343`	`+ Assert.ThrowsException<ArgumentException>(`
`1344`	`1344`	`() => _stack.GlobalField("").Delete(),`
`1345`		`- "Expected InvalidOperationException for empty UID");`
	`1345`	`+ "Expected ArgumentException for empty UID");`
`1346`	`1346`	`}`
`1347`	`1347`
`1348`	`1348`	`[TestMethod]`
`@@ -1468,9 +1468,9 @@ public async Task Test038_Should_Fail_Fetch_Async_With_Empty_UID()`
`1468`	`1468`	`try`
`1469`	`1469`	`{`
`1470`	`1470`	`await _stack.GlobalField("").FetchAsync();`
`1471`		`- Assert.Fail("Expected InvalidOperationException for empty UID");`
	`1471`	`+ Assert.Fail("Expected ArgumentException for empty UID");`
`1472`	`1472`	`}`
`1473`		`- catch (InvalidOperationException)`
	`1473`	`+ catch (ArgumentException)`
`1474`	`1474`	`{`
`1475`	`1475`	`// Expected exception - test passes`
`1476`	`1476`	`}`
`@@ -1485,9 +1485,9 @@ public async Task Test039_Should_Fail_Delete_Async_With_Empty_UID()`
`1485`	`1485`	`try`
`1486`	`1486`	`{`
`1487`	`1487`	`await _stack.GlobalField("").DeleteAsync();`
`1488`		`- Assert.Fail("Expected InvalidOperationException for empty UID");`
	`1488`	`+ Assert.Fail("Expected ArgumentException for empty UID");`
`1489`	`1489`	`}`
`1490`		`- catch (InvalidOperationException)`
	`1490`	`+ catch (ArgumentException)`
`1491`	`1491`	`{`
`1492`	`1492`	`// Expected exception - test passes`
`1493`	`1493`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1013,7 +1013,7 @@ await AssertLogger.ThrowsContentstackErrorAsync(`
`1013`	`1013`	`public void Test044_Should_Fail_With_Null_Environment_UID_Sync()`
`1014`	`1014`	`{`
`1015`	`1015`	`TestOutputLogger.LogContext("TestScenario", "Test044_Should_Fail_With_Null_Environment_UID_Sync");`
`1016`		`- AssertLogger.ThrowsException<InvalidOperationException>(`
	`1016`	`+ AssertLogger.ThrowsException<ArgumentException>(`
`1017`	`1017`	`() => _stack.Environment(null).Fetch(),`
`1018`	`1018`	`"FetchNullUidSync");`
`1019`	`1019`	`}`
`@@ -1022,7 +1022,7 @@ public void Test044_Should_Fail_With_Null_Environment_UID_Sync()`
`1022`	`1022`	`public void Test045_Should_Fail_With_Empty_Environment_UID_Sync()`
`1023`	`1023`	`{`
`1024`	`1024`	`TestOutputLogger.LogContext("TestScenario", "Test045_Should_Fail_With_Empty_Environment_UID_Sync");`
`1025`		`- AssertLogger.ThrowsException<InvalidOperationException>(`
	`1025`	`+ AssertLogger.ThrowsException<ArgumentException>(`
`1026`	`1026`	`() => _stack.Environment("").Fetch(),`
`1027`	`1027`	`"FetchEmptyUidSync");`
`1028`	`1028`	`}`
`@@ -1123,15 +1123,15 @@ public async Task Test050_Should_Fail_With_Null_Environment_UID_Async()`
`1123`	`1123`	`try`
`1124`	`1124`	`{`
`1125`	`1125`	`await _stack.Environment(null).FetchAsync();`
`1126`		`- AssertLogger.Fail("Expected InvalidOperationException for null UID");`
	`1126`	`+ AssertLogger.Fail("Expected ArgumentException for null UID");`
`1127`	`1127`	`}`
`1128`		`- catch (InvalidOperationException)`
	`1128`	`+ catch (ArgumentException)`
`1129`	`1129`	`{`
`1130`		`- AssertLogger.IsTrue(true, "InvalidOperationException thrown as expected", "FetchNullUidAsync");`
	`1130`	`+ AssertLogger.IsTrue(true, "ArgumentException thrown as expected", "FetchNullUidAsync");`
`1131`	`1131`	`}`
`1132`	`1132`	`catch (Exception ex)`
`1133`	`1133`	`{`
`1134`		`- AssertLogger.Fail($"Expected InvalidOperationException but got {ex.GetType().Name}");`
	`1134`	`+ AssertLogger.Fail($"Expected ArgumentException but got {ex.GetType().Name}");`
`1135`	`1135`	`}`
`1136`	`1136`	`}`
`1137`	`1137`
`@@ -1142,15 +1142,15 @@ public async Task Test051_Should_Fail_With_Empty_Environment_UID_Async()`
`1142`	`1142`	`try`
`1143`	`1143`	`{`
`1144`	`1144`	`await _stack.Environment("").FetchAsync();`
`1145`		`- AssertLogger.Fail("Expected InvalidOperationException for empty UID");`
	`1145`	`+ AssertLogger.Fail("Expected ArgumentException for empty UID");`
`1146`	`1146`	`}`
`1147`		`- catch (InvalidOperationException)`
	`1147`	`+ catch (ArgumentException)`
`1148`	`1148`	`{`
`1149`		`- AssertLogger.IsTrue(true, "InvalidOperationException thrown as expected", "FetchEmptyUidAsync");`
	`1149`	`+ AssertLogger.IsTrue(true, "ArgumentException thrown as expected", "FetchEmptyUidAsync");`
`1150`	`1150`	`}`
`1151`	`1151`	`catch (Exception ex)`
`1152`	`1152`	`{`
`1153`		`- AssertLogger.Fail($"Expected InvalidOperationException but got {ex.GetType().Name}");`
	`1153`	`+ AssertLogger.Fail($"Expected ArgumentException but got {ex.GetType().Name}");`
`1154`	`1154`	`}`
`1155`	`1155`	`}`
`1156`	`1156`
Original file line number	Diff line number	Diff line change
`@@ -3151,7 +3151,7 @@ public void Test141_Should_Fail_With_Null_Workflow_UID_Parameter()`
`3151`	`3151`	`try`
`3152`	`3152`	`{`
`3153`	`3153`	`// Act & Assert - SDK should validate UID before API call`
`3154`		`- AssertLogger.ThrowsException<InvalidOperationException>(() =>`
	`3154`	`+ AssertLogger.ThrowsException<ArgumentException>(() =>`
`3155`	`3155`	`{`
`3156`	`3156`	`_stack.Workflow(null).Fetch();`
`3157`	`3157`	`}, "fetchWorkflowNullUID");`
`@@ -3160,7 +3160,7 @@ public void Test141_Should_Fail_With_Null_Workflow_UID_Parameter()`
`3160`	`3160`	`}`
`3161`	`3161`	`catch (Exception ex)`
`3162`	`3162`	`{`
`3163`		`- FailWithError("Expected InvalidOperationException for null workflow UID", ex);`
	`3163`	`+ FailWithError("Expected ArgumentException for null workflow UID", ex);`
`3164`	`3164`	`}`
`3165`	`3165`	`}`
`3166`	`3166`
`@@ -3172,7 +3172,7 @@ public void Test142_Should_Fail_With_Empty_Workflow_UID_Parameter()`
`3172`	`3172`	`try`
`3173`	`3173`	`{`
`3174`	`3174`	`// Act & Assert - SDK should validate UID before API call`
`3175`		`- AssertLogger.ThrowsException<InvalidOperationException>(() =>`
	`3175`	`+ AssertLogger.ThrowsException<ArgumentException>(() =>`
`3176`	`3176`	`{`
`3177`	`3177`	`_stack.Workflow("").Fetch();`
`3178`	`3178`	`}, "fetchWorkflowEmptyUID");`
`@@ -3181,7 +3181,7 @@ public void Test142_Should_Fail_With_Empty_Workflow_UID_Parameter()`
`3181`	`3181`	`}`
`3182`	`3182`	`catch (Exception ex)`
`3183`	`3183`	`{`
`3184`		`- FailWithError("Expected InvalidOperationException for empty workflow UID", ex);`
	`3184`	`+ FailWithError("Expected ArgumentException for empty workflow UID", ex);`
`3185`	`3185`	`}`
`3186`	`3186`	`}`
`3187`	`3187`