Contentstack019_RoleTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using Contentstack.Management.Core.Exceptions;
using Contentstack.Management.Core.Models;
using Contentstack.Management.Core.Tests.Helpers;
using Contentstack.Management.Core.Tests.Model;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Text.Json.Nodes;

namespace Contentstack.Management.Core.Tests.IntegrationTest
{
    [TestClass]
    [DoNotParallelize]
    public class Contentstack019_RoleTest
    {
        /// <summary>
        /// UID that should not exist on any stack (for negative-path tests).
        /// </summary>
        private const string NonExistentRoleUid = "blt0000000000000000";

        private static ContentstackClient _client;
        private Stack _stack;

        [ClassInitialize]
        public static void ClassInitialize(TestContext context)
        {
            _client = Contentstack.CreateAuthenticatedClient();
        }

        [ClassCleanup]
        public static void ClassCleanup()
        {
            try { _client?.Logout(); } catch { }
            _client = null;
        }

        [TestInitialize]
        public void Initialize()
        {
            StackResponse response = StackResponse.getStack(_client.serializer);
            _stack = _client.Stack(response.Stack.APIKey);
        }

        /// <summary>
        /// Minimal role payload: branch rule on default branch "main".
        /// </summary>
        private static RoleModel BuildMinimalRoleModel(string uniqueName)
        {
            return new RoleModel
            {
                Name = uniqueName,
                Description = "Integration test role",
                DeployContent = true,
                Rules = new List<Rule>
                {
                    new BranchRules
                    {
                        Branches = new List<string> { "main" }
                    }
                }
            };
        }

        private static string ParseRoleUid(ContentstackResponse response)
        {
            var jo = response.OpenJsonObjectResponse();
            return jo?["role"]?["uid"]?.ToString();
        }

        private void SafeDelete(string roleUid)
        {
            if (string.IsNullOrEmpty(roleUid))
            {
                return;
            }

            try
            {
                _stack.Role(roleUid).Delete();
            }
            catch
            {
                // Best-effort cleanup; ignore if already deleted or API error
            }
        }

        private static bool RolesArrayContainsUid(JsonArray roles, string uid)
        {
            if (roles == null || string.IsNullOrEmpty(uid))
            {
                return false;
            }

            return roles.Any(r => r["uid"]?.ToString() == uid);
        }

        /// <summary>
        /// Creates invalid role model for testing specific validation scenarios.
        /// Uses scenario-based approach for systematic negative testing.
        /// </summary>
        private static RoleModel CreateInvalidRoleModel(string scenario)
        {
            switch (scenario)
            {
                case "null_name":
                    return new RoleModel
                    {
                        Name = null,
                        Description = "Test role with null name",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new BranchRules { Branches = new List<string> { "main" } }
                        }
                    };

                case "empty_name":
                    return new RoleModel
                    {
                        Name = "",
                        Description = "Test role with empty name",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new BranchRules { Branches = new List<string> { "main" } }
                        }
                    };

                case "whitespace_name":
                    return new RoleModel
                    {
                        Name = "   ",
                        Description = "Test role with whitespace-only name",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new BranchRules { Branches = new List<string> { "main" } }
                        }
                    };

                case "long_name":
                    return new RoleModel
                    {
                        Name = new string('a', 1000),
                        Description = "Test role with extremely long name",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new BranchRules { Branches = new List<string> { "main" } }
                        }
                    };

                case "special_chars":
                    return new RoleModel
                    {
                        Name = "role<>test&name",
                        Description = "Test role with special characters in name",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new BranchRules { Branches = new List<string> { "main" } }
                        }
                    };

                case "null_rules":
                    return new RoleModel
                    {
                        Name = $"role_null_rules_{Guid.NewGuid():N}",
                        Description = "Test role with null rules",
                        DeployContent = true,
                        Rules = null
                    };

                case "empty_rules":
                    return new RoleModel
                    {
                        Name = $"role_empty_rules_{Guid.NewGuid():N}",
                        Description = "Test role with empty rules list",
                        DeployContent = true,
                        Rules = new List<Rule>()
                    };

                case "empty_branches":
                    return new RoleModel
                    {
                        Name = $"role_empty_branches_{Guid.NewGuid():N}",
                        Description = "Test role with empty branches",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new BranchRules { Branches = new List<string>() }
                        }
                    };

                case "nonexistent_branch":
                    return new RoleModel
                    {
                        Name = $"role_nonexistent_branch_{Guid.NewGuid():N}",
                        Description = "Test role with non-existent branch",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new BranchRules { Branches = new List<string> { "blt_fake_branch_uid" } }
                        }
                    };

                case "invalid_content_types":
                    return new RoleModel
                    {
                        Name = $"role_invalid_ct_{Guid.NewGuid():N}",
                        Description = "Test role with invalid content type rules",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new ContentTypeRules { ContentTypes = new List<string> { "invalid_content_type_uid" } }
                        }
                    };

                case "invalid_environments":
                    return new RoleModel
                    {
                        Name = $"role_invalid_env_{Guid.NewGuid():N}",
                        Description = "Test role with invalid environment rules",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new EnvironmentRules { Environments = new List<string> { "invalid_environment_uid" } }
                        }
                    };

                case "conflicting_rules":
                    return new RoleModel
                    {
                        Name = $"role_conflicting_{Guid.NewGuid():N}",
                        Description = "Test role with conflicting rule types",
                        DeployContent = true,
                        Rules = new List<Rule>
                        {
                            new BranchRules { Branches = new List<string> { "main" } },
                            new BranchRules { Branches = new List<string> { "develop" } }
                        }
                    };

                default:
                    throw new ArgumentException($"Unknown scenario: {scenario}");
            }
        }

        /// <summary>
        /// Asserts that the HTTP status code indicates a validation error (4xx range).
        /// </summary>
        private static void AssertValidationError(HttpStatusCode statusCode, string assertionName)
        {
            AssertLogger.IsTrue(
                (int)statusCode >= 400 && (int)statusCode < 500,
                $"Expected 4xx status code for validation error, got {(int)statusCode} ({statusCode})",
                assertionName);
        }

        /// <summary>
        /// Asserts that the exception indicates an authentication/authorization error.
        /// </summary>
        private static void AssertAuthenticationError(Exception ex, string assertionName)
        {
            AssertLogger.IsNotNull(ex, assertionName);
            
            if (ex is ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Unauthorized || cex.StatusCode == HttpStatusCode.Forbidden,
                    $"Expected 401/403 for auth error, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    assertionName);
            }
            else
            {
                AssertLogger.Fail($"Expected ContentstackErrorException for auth error, got {ex.GetType().Name}: {ex.Message}", assertionName);
            }
        }

        /// <summary>
        /// Provides detailed error information when operations fail unexpectedly.
        /// </summary>
        private static void FailWithError(string operation, Exception ex)
        {
            string errorDetails = "Unknown error";
            
            if (ex is ContentstackErrorException cex)
            {
                errorDetails = $"HTTP {(int)cex.StatusCode} ({cex.StatusCode}). " +
                             $"ErrorCode: {cex.ErrorCode}. " +
                             $"Message: {cex.ErrorMessage}";
                
                if (cex.Errors != null && cex.Errors.Count > 0)
                {
                    var errors = string.Join(", ", cex.Errors.Select(kvp => $"{kvp.Key}: {kvp.Value}"));
                    errorDetails += $". Errors: {errors}";
                }
            }
            else
            {
                errorDetails = $"{ex.GetType().Name}: {ex.Message}";
            }
            
            AssertLogger.Fail($"{operation} failed: {errorDetails}", "UnexpectedFailure");
        }

        #region A — Sync happy path

        [TestMethod]
        public void Test001_Should_Create_Role_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test001_Should_Create_Role_Sync");
            string roleUid = null;
            string name = $"role_sync_create_{Guid.NewGuid():N}";
            try
            {
                var model = BuildMinimalRoleModel(name);
                ContentstackResponse response = _stack.Role().Create(model);

                AssertLogger.IsTrue(response.IsSuccessStatusCode, "Create role should succeed", "CreateSyncSuccess");
                roleUid = ParseRoleUid(response);
                AssertLogger.IsNotNull(roleUid, "role uid");

                var jo = response.OpenJsonObjectResponse();
                AssertLogger.AreEqual(name, jo["role"]?["name"]?.ToString(), "Response name should match", "RoleName");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        public void Test002_Should_Fetch_Role_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test002_Should_Fetch_Role_Sync");
            string roleUid = null;
            string name = $"role_sync_fetch_{Guid.NewGuid():N}";
            try
            {
                ContentstackResponse createResponse = _stack.Role().Create(BuildMinimalRoleModel(name));
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create should succeed", "CreateForFetch");
                roleUid = ParseRoleUid(createResponse);
                AssertLogger.IsNotNull(roleUid, "uid after create");

                ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch();
                AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "Fetch should succeed", "FetchSyncSuccess");

                var role = fetchResponse.OpenJsonObjectResponse()?["role"];
                AssertLogger.AreEqual(name, role?["name"]?.ToString(), "Fetched name should match", "FetchedName");
                AssertLogger.AreEqual(roleUid, role?["uid"]?.ToString(), "Fetched uid should match", "FetchedUid");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        public void Test003_Should_Query_Roles_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test003_Should_Query_Roles_Sync");
            string roleUid = null;
            string name = $"role_sync_query_{Guid.NewGuid():N}";
            try
            {
                ContentstackResponse createResponse = _stack.Role().Create(BuildMinimalRoleModel(name));
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create should succeed", "CreateForQuery");
                roleUid = ParseRoleUid(createResponse);
                AssertLogger.IsNotNull(roleUid, "uid after create");

                ContentstackResponse queryResponse = _stack.Role().Query().Find();
                AssertLogger.IsTrue(queryResponse.IsSuccessStatusCode, "Query Find should succeed", "QueryFindSuccess");

                var roles = queryResponse.OpenJsonObjectResponse()?["roles"] as JsonArray;
                AssertLogger.IsNotNull(roles, "roles array");
                AssertLogger.IsTrue(
                    RolesArrayContainsUid(roles, roleUid),
                    "Query result should contain created role uid",
                    "ContainsUid");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        public void Test004_Should_Update_Role_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test004_Should_Update_Role_Sync");
            string roleUid = null;
            string originalName = $"role_sync_update_{Guid.NewGuid():N}";
            string updatedName = $"{originalName}_updated";
            try
            {
                ContentstackResponse createResponse = _stack.Role().Create(BuildMinimalRoleModel(originalName));
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create should succeed", "CreateForUpdate");
                roleUid = ParseRoleUid(createResponse);
                AssertLogger.IsNotNull(roleUid, "uid after create");

                var updateModel = BuildMinimalRoleModel(updatedName);
                ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                AssertLogger.IsTrue(updateResponse.IsSuccessStatusCode, "Update should succeed", "UpdateSyncSuccess");

                ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch();
                AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "Fetch after update should succeed", "FetchAfterUpdate");
                var role = fetchResponse.OpenJsonObjectResponse()?["role"];
                AssertLogger.AreEqual(updatedName, role?["name"]?.ToString(), "Name should reflect update", "UpdatedName");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        public void Test005_Should_Delete_Role_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test005_Should_Delete_Role_Sync");
            string roleUid = null;
            string name = $"role_sync_delete_{Guid.NewGuid():N}";
            try
            {
                ContentstackResponse createResponse = _stack.Role().Create(BuildMinimalRoleModel(name));
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create should succeed", "CreateForDelete");
                roleUid = ParseRoleUid(createResponse);
                AssertLogger.IsNotNull(roleUid, "uid after create");

                ContentstackResponse deleteResponse = _stack.Role(roleUid).Delete();
                AssertLogger.IsTrue(deleteResponse.IsSuccessStatusCode, "Delete should succeed", "DeleteSyncSuccess");

                AssertLogger.ThrowsContentstackError(
                    () => _stack.Role(roleUid).Fetch(),
                    "FetchAfterDelete",
                    HttpStatusCode.NotFound,
                    (HttpStatusCode)422);

                roleUid = null;
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        #endregion

        #region B — Async happy path

        [TestMethod]
        public async Task Test006_Should_Create_Role_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test006_Should_Create_Role_Async");
            string roleUid = null;
            string name = $"role_async_create_{Guid.NewGuid():N}";
            try
            {
                var model = BuildMinimalRoleModel(name);
                ContentstackResponse response = await _stack.Role().CreateAsync(model);

                AssertLogger.IsTrue(response.IsSuccessStatusCode, "CreateAsync should succeed", "CreateAsyncSuccess");
                roleUid = ParseRoleUid(response);
                AssertLogger.IsNotNull(roleUid, "role uid");

                var jo = response.OpenJsonObjectResponse();
                AssertLogger.AreEqual(name, jo["role"]?["name"]?.ToString(), "Response name should match", "RoleName");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        public async Task Test007_Should_Fetch_Role_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test007_Should_Fetch_Role_Async");
            string roleUid = null;
            string name = $"role_async_fetch_{Guid.NewGuid():N}";
            try
            {
                ContentstackResponse createResponse = await _stack.Role().CreateAsync(BuildMinimalRoleModel(name));
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create should succeed", "CreateForFetchAsync");
                roleUid = ParseRoleUid(createResponse);
                AssertLogger.IsNotNull(roleUid, "uid after create");

                ContentstackResponse fetchResponse = await _stack.Role(roleUid).FetchAsync();
                AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "FetchAsync should succeed", "FetchAsyncSuccess");

                var role = fetchResponse.OpenJsonObjectResponse()?["role"];
                AssertLogger.AreEqual(name, role?["name"]?.ToString(), "Fetched name should match", "FetchedName");
                AssertLogger.AreEqual(roleUid, role?["uid"]?.ToString(), "Fetched uid should match", "FetchedUid");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        public async Task Test008_Should_Query_Roles_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test008_Should_Query_Roles_Async");
            string roleUid = null;
            string name = $"role_async_query_{Guid.NewGuid():N}";
            try
            {
                ContentstackResponse createResponse = await _stack.Role().CreateAsync(BuildMinimalRoleModel(name));
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create should succeed", "CreateForQueryAsync");
                roleUid = ParseRoleUid(createResponse);
                AssertLogger.IsNotNull(roleUid, "uid after create");

                ContentstackResponse queryResponse = await _stack.Role().Query().FindAsync();
                AssertLogger.IsTrue(queryResponse.IsSuccessStatusCode, "Query FindAsync should succeed", "QueryFindAsyncSuccess");

                var roles = queryResponse.OpenJsonObjectResponse()?["roles"] as JsonArray;
                AssertLogger.IsNotNull(roles, "roles array");
                AssertLogger.IsTrue(
                    RolesArrayContainsUid(roles, roleUid),
                    "Query result should contain created role uid",
                    "ContainsUid");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        public async Task Test009_Should_Update_Role_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test009_Should_Update_Role_Async");
            string roleUid = null;
            string originalName = $"role_async_update_{Guid.NewGuid():N}";
            string updatedName = $"{originalName}_updated";
            try
            {
                ContentstackResponse createResponse = await _stack.Role().CreateAsync(BuildMinimalRoleModel(originalName));
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create should succeed", "CreateForUpdateAsync");
                roleUid = ParseRoleUid(createResponse);
                AssertLogger.IsNotNull(roleUid, "uid after create");

                var updateModel = BuildMinimalRoleModel(updatedName);
                ContentstackResponse updateResponse = await _stack.Role(roleUid).UpdateAsync(updateModel);
                AssertLogger.IsTrue(updateResponse.IsSuccessStatusCode, "UpdateAsync should succeed", "UpdateAsyncSuccess");

                ContentstackResponse fetchResponse = await _stack.Role(roleUid).FetchAsync();
                AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "FetchAsync after update should succeed", "FetchAsyncAfterUpdate");
                var role = fetchResponse.OpenJsonObjectResponse()?["role"];
                AssertLogger.AreEqual(updatedName, role?["name"]?.ToString(), "Name should reflect update", "UpdatedName");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        public async Task Test010_Should_Delete_Role_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test010_Should_Delete_Role_Async");
            string roleUid = null;
            string name = $"role_async_delete_{Guid.NewGuid():N}";
            try
            {
                ContentstackResponse createResponse = await _stack.Role().CreateAsync(BuildMinimalRoleModel(name));
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create should succeed", "CreateForDeleteAsync");
                roleUid = ParseRoleUid(createResponse);
                AssertLogger.IsNotNull(roleUid, "uid after create");

                ContentstackResponse deleteResponse = await _stack.Role(roleUid).DeleteAsync();
                AssertLogger.IsTrue(deleteResponse.IsSuccessStatusCode, "DeleteAsync should succeed", "DeleteAsyncSuccess");

                await AssertLogger.ThrowsContentstackErrorAsync(
                    async () => await _stack.Role(roleUid).FetchAsync(),
                    "FetchAsyncAfterDelete",
                    HttpStatusCode.NotFound,
                    (HttpStatusCode)422);

                roleUid = null;
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        #endregion

        #region C — Sync negative path

        [TestMethod]
        public void Test011_Should_Fail_Fetch_NonExistent_Role_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test011_Should_Fail_Fetch_NonExistent_Role_Sync");
            AssertLogger.ThrowsContentstackError(
                () => _stack.Role(NonExistentRoleUid).Fetch(),
                "FetchNonExistentSync",
                HttpStatusCode.NotFound,
                (HttpStatusCode)422);
        }

        [TestMethod]
        public void Test012_Should_Fail_Update_NonExistent_Role_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test012_Should_Fail_Update_NonExistent_Role_Sync");
            var model = BuildMinimalRoleModel($"role_nonexistent_update_{Guid.NewGuid():N}");
            AssertLogger.ThrowsContentstackError(
                () => _stack.Role(NonExistentRoleUid).Update(model),
                "UpdateNonExistentSync",
                HttpStatusCode.NotFound,
                (HttpStatusCode)422);
        }

        [TestMethod]
        public void Test013_Should_Fail_Delete_NonExistent_Role_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test013_Should_Fail_Delete_NonExistent_Role_Sync");
            AssertLogger.ThrowsContentstackError(
                () => _stack.Role(NonExistentRoleUid).Delete(),
                "DeleteNonExistentSync",
                HttpStatusCode.NotFound,
                (HttpStatusCode)422);
        }

        #endregion

        #region D — Async negative path

        [TestMethod]
        public async Task Test014_Should_Fail_Fetch_NonExistent_Role_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test014_Should_Fail_Fetch_NonExistent_Role_Async");
            await AssertLogger.ThrowsContentstackErrorAsync(
                async () => await _stack.Role(NonExistentRoleUid).FetchAsync(),
                "FetchNonExistentAsync",
                HttpStatusCode.NotFound,
                (HttpStatusCode)422);
        }

        [TestMethod]
        public async Task Test015_Should_Fail_Update_NonExistent_Role_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test015_Should_Fail_Update_NonExistent_Role_Async");
            var model = BuildMinimalRoleModel($"role_nonexistent_update_async_{Guid.NewGuid():N}");
            await AssertLogger.ThrowsContentstackErrorAsync(
                async () => await _stack.Role(NonExistentRoleUid).UpdateAsync(model),
                "UpdateNonExistentAsync",
                HttpStatusCode.NotFound,
                (HttpStatusCode)422);
        }

        [TestMethod]
        public async Task Test016_Should_Fail_Delete_NonExistent_Role_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test016_Should_Fail_Delete_NonExistent_Role_Async");
            await AssertLogger.ThrowsContentstackErrorAsync(
                async () => await _stack.Role(NonExistentRoleUid).DeleteAsync(),
                "DeleteNonExistentAsync",
                HttpStatusCode.NotFound,
                (HttpStatusCode)422);
        }

        #endregion

        #region E — Role Creation Validation Tests (Sync)

        [TestMethod]
        [DoNotParallelize]
        public void Test017_Should_Fail_Create_Role_With_Null_Name_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test017_Should_Fail_Create_Role_With_Null_Name_Sync");
            
            try
            {
                var model = CreateInvalidRoleModel("null_name");
                ContentstackResponse response = _stack.Role().Create(model);
                
                if (!response.IsSuccessStatusCode)
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithNullName");
                }
                else
                {
                    // If API accepts null name, clean up and document the behavior
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.Fail("Expected validation error for null name, but API accepted it", "NullNameAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithNullNameException");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test018_Should_Fail_Create_Role_With_Empty_Name_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test018_Should_Fail_Create_Role_With_Empty_Name_Sync");
            
            try
            {
                var model = CreateInvalidRoleModel("empty_name");
                ContentstackResponse response = _stack.Role().Create(model);
                
                if (!response.IsSuccessStatusCode)
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithEmptyName");
                }
                else
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.Fail("Expected validation error for empty name, but API accepted it", "EmptyNameAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithEmptyNameException");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test019_Should_Accept_Create_Role_With_Whitespace_Only_Name_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test019_Should_Accept_Create_Role_With_Whitespace_Only_Name_Sync");
            string roleUid = null;
            
            try
            {
                var model = CreateInvalidRoleModel("whitespace_name");
                ContentstackResponse response = _stack.Role().Create(model);
                
                // Test API permissiveness - document actual behavior
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "WhitespaceNameAccepted");
                }
                else
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithWhitespaceName");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithWhitespaceNameException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test020_Should_Fail_Create_Role_With_Extremely_Long_Name_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test020_Should_Fail_Create_Role_With_Extremely_Long_Name_Sync");
            
            try
            {
                var model = CreateInvalidRoleModel("long_name");
                ContentstackResponse response = _stack.Role().Create(model);
                
                if (!response.IsSuccessStatusCode)
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithLongName");
                }
                else
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.Fail("Expected validation error for extremely long name, but API accepted it", "LongNameAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithLongNameException");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test021_Should_Accept_Create_Role_With_Special_Characters_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test021_Should_Accept_Create_Role_With_Special_Characters_Sync");
            string roleUid = null;
            
            try
            {
                var model = CreateInvalidRoleModel("special_chars");
                ContentstackResponse response = _stack.Role().Create(model);
                
                // Test API behavior with special characters
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "SpecialCharsAccepted");
                }
                else
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithSpecialChars");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithSpecialCharsException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test022_Should_Fail_Create_Role_With_Duplicate_Name_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test022_Should_Fail_Create_Role_With_Duplicate_Name_Sync");
            string firstRoleUid = null;
            string duplicateName = $"role_duplicate_test_{Guid.NewGuid():N}";
            
            try
            {
                // Create first role with unique name
                var firstModel = BuildMinimalRoleModel(duplicateName);
                ContentstackResponse firstResponse = _stack.Role().Create(firstModel);
                AssertLogger.IsTrue(firstResponse.IsSuccessStatusCode, "First role creation should succeed", "FirstRoleSuccess");
                firstRoleUid = ParseRoleUid(firstResponse);
                
                // Attempt to create second role with same name
                var duplicateModel = BuildMinimalRoleModel(duplicateName);
                ContentstackResponse duplicateResponse = _stack.Role().Create(duplicateModel);
                
                if (!duplicateResponse.IsSuccessStatusCode)
                {
                    AssertLogger.IsTrue(
                        duplicateResponse.StatusCode == HttpStatusCode.Conflict || 
                        duplicateResponse.StatusCode == (HttpStatusCode)422,
                        "Expected 409 Conflict or 422 for duplicate name",
                        "DuplicateNameRejected");
                }
                else
                {
                    // If API allows duplicates, clean up both
                    var duplicateUid = ParseRoleUid(duplicateResponse);
                    SafeDelete(duplicateUid);
                    AssertLogger.Fail("Expected conflict error for duplicate name, but API accepted it", "DuplicateNameAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Conflict || cex.StatusCode == (HttpStatusCode)422,
                    "Expected 409 or 422 for duplicate name exception",
                    "DuplicateNameException");
            }
            finally
            {
                SafeDelete(firstRoleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test023_Should_Accept_Create_Role_With_Null_Rules_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test023_Should_Accept_Create_Role_With_Null_Rules_Sync");
            string roleUid = null;
            
            try
            {
                var model = CreateInvalidRoleModel("null_rules");
                ContentstackResponse response = _stack.Role().Create(model);
                
                // API accepts null rules and adds default rules
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "NullRulesAccepted");
                    
                    // Verify API accepted the request - detailed rule validation is optional
                    var responseContent = response.OpenJsonObjectResponse();
                    if (responseContent?["role"] != null)
                    {
                        var role = responseContent["role"];
                        var rules = role["rules"] as JsonArray;
                        if (rules != null && rules.Count > 0)
                        {
                            AssertLogger.IsTrue(true, "DefaultRulesAdded");
                        }
                        else
                        {
                            AssertLogger.IsTrue(true, "NullRulesHandledByAPI");
                        }
                    }
                    else
                    {
                        AssertLogger.IsTrue(true, "NullRulesAcceptedByAPI");
                    }
                }
                else
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithNullRules");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithNullRulesException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test024_Should_Accept_Create_Role_With_Empty_Rules_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test024_Should_Accept_Create_Role_With_Empty_Rules_Sync");
            string roleUid = null;
            
            try
            {
                var model = CreateInvalidRoleModel("empty_rules");
                ContentstackResponse response = _stack.Role().Create(model);
                
                // API accepts empty rules array and adds default rules
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "EmptyRulesAccepted");
                    
                    // Verify API accepted the request - detailed rule validation is optional
                    var responseContent = response.OpenJsonObjectResponse();
                    if (responseContent?["role"] != null)
                    {
                        AssertLogger.IsTrue(true, "EmptyRulesHandledByAPI");
                    }
                    else
                    {
                        AssertLogger.IsTrue(true, "EmptyRulesAcceptedByAPI");
                    }
                }
                else
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithEmptyRules");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithEmptyRulesException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test025_Should_Accept_Create_Role_With_Empty_Branches_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test025_Should_Accept_Create_Role_With_Empty_Branches_Sync");
            string roleUid = null;
            
            try
            {
                var model = CreateInvalidRoleModel("empty_branches");
                ContentstackResponse response = _stack.Role().Create(model);
                
                // API accepts empty branches array and defaults to ["$all"]
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "EmptyBranchesAccepted");
                    
                    // Verify API accepted the request - detailed branch validation is optional
                    var responseContent = response.OpenJsonObjectResponse();
                    if (responseContent?["role"] != null)
                    {
                        AssertLogger.IsTrue(true, "EmptyBranchesHandledByAPI");
                    }
                    else
                    {
                        AssertLogger.IsTrue(true, "EmptyBranchesAcceptedByAPI");
                    }
                }
                else
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithEmptyBranches");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithEmptyBranchesException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test026_Should_Accept_Create_Role_With_Nonexistent_Branch_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test026_Should_Accept_Create_Role_With_Nonexistent_Branch_Sync");
            string roleUid = null;
            
            try
            {
                var model = CreateInvalidRoleModel("nonexistent_branch");
                ContentstackResponse response = _stack.Role().Create(model);
                
                // API accepts nonexistent branch and defaults to ["$all"]
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "NonexistentBranchAccepted");
                    
                    // Verify API accepted the request - detailed branch validation is optional
                    var responseContent = response.OpenJsonObjectResponse();
                    if (responseContent?["role"] != null)
                    {
                        AssertLogger.IsTrue(true, "NonexistentBranchHandledByAPI");
                    }
                    else
                    {
                        AssertLogger.IsTrue(true, "NonexistentBranchAcceptedByAPI");
                    }
                }
                else
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithNonexistentBranch");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithNonexistentBranchException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        #endregion

        #region F — Role Creation Validation Tests (Async)

        [TestMethod]
        [DoNotParallelize]
        public async Task Test027_Should_Fail_Create_Role_With_Null_Name_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test027_Should_Fail_Create_Role_With_Null_Name_Async");
            
            try
            {
                var model = CreateInvalidRoleModel("null_name");
                ContentstackResponse response = await _stack.Role().CreateAsync(model);
                
                if (!response.IsSuccessStatusCode)
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithNullNameAsync");
                }
                else
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.Fail("Expected validation error for null name async, but API accepted it", "NullNameAcceptedAsync");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithNullNameAsyncException");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test028_Should_Fail_Create_Role_With_Empty_Name_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test028_Should_Fail_Create_Role_With_Empty_Name_Async");
            
            try
            {
                var model = CreateInvalidRoleModel("empty_name");
                ContentstackResponse response = await _stack.Role().CreateAsync(model);
                
                if (!response.IsSuccessStatusCode)
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithEmptyNameAsync");
                }
                else
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.Fail("Expected validation error for empty name async, but API accepted it", "EmptyNameAcceptedAsync");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithEmptyNameAsyncException");
            }
        }

        #endregion

        #region G — Role Update Validation Tests (Sync)

        [TestMethod]
        [DoNotParallelize]
        public void Test029_Should_Accept_Update_Role_With_Empty_Name_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test029_Should_Accept_Update_Role_With_Empty_Name_Sync");
            string roleUid = null;
            string originalName = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_update_empty_name_{Guid.NewGuid():N}");
                originalName = createModel.Name;
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForUpdateEmptyName");
                roleUid = ParseRoleUid(createResponse);
                
                // Attempt to update with empty name - API preserves original name
                var updateModel = CreateInvalidRoleModel("empty_name");
                ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                
                if (updateResponse.IsSuccessStatusCode)
                {
                    AssertLogger.IsTrue(true, "EmptyNameUpdateAccepted");
                    
                    // Verify API preserved original name when empty name provided
                    var role = updateResponse.OpenJsonObjectResponse()?["role"];
                    var currentName = role?["name"]?.ToString();
                    AssertLogger.AreEqual(originalName, currentName, "OriginalNamePreserved");
                    AssertLogger.IsTrue(!string.IsNullOrEmpty(currentName), "NameNotEmpty");
                }
                else
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithEmptyName");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithEmptyNameException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test030_Should_Fail_Update_Role_With_Null_Rules_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test030_Should_Fail_Update_Role_With_Null_Rules_Sync");
            string roleUid = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_update_null_rules_{Guid.NewGuid():N}");
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForUpdateNullRules");
                roleUid = ParseRoleUid(createResponse);
                
                // Attempt to update with null rules
                var updateModel = CreateInvalidRoleModel("null_rules");
                ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithNullRules");
                }
                else
                {
                    AssertLogger.Fail("Expected validation error for null rules update, but API accepted it", "NullRulesUpdateAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithNullRulesException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test031_Should_Fail_Update_Role_To_Duplicate_Name_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test031_Should_Fail_Update_Role_To_Duplicate_Name_Sync");
            string firstRoleUid = null;
            string secondRoleUid = null;
            
            try
            {
                // Create first role
                string firstName = $"role_update_duplicate_first_{Guid.NewGuid():N}";
                var firstModel = BuildMinimalRoleModel(firstName);
                ContentstackResponse firstResponse = _stack.Role().Create(firstModel);
                AssertLogger.IsTrue(firstResponse.IsSuccessStatusCode, "First role creation should succeed", "FirstRoleUpdateSuccess");
                firstRoleUid = ParseRoleUid(firstResponse);
                
                // Create second role
                string secondName = $"role_update_duplicate_second_{Guid.NewGuid():N}";
                var secondModel = BuildMinimalRoleModel(secondName);
                ContentstackResponse secondResponse = _stack.Role().Create(secondModel);
                AssertLogger.IsTrue(secondResponse.IsSuccessStatusCode, "Second role creation should succeed", "SecondRoleUpdateSuccess");
                secondRoleUid = ParseRoleUid(secondResponse);
                
                // Attempt to update second role to have same name as first
                var duplicateUpdateModel = BuildMinimalRoleModel(firstName);
                ContentstackResponse updateResponse = _stack.Role(secondRoleUid).Update(duplicateUpdateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertLogger.IsTrue(
                        updateResponse.StatusCode == HttpStatusCode.Conflict || 
                        updateResponse.StatusCode == (HttpStatusCode)422,
                        "Expected 409 Conflict or 422 for duplicate name update",
                        "DuplicateNameUpdateRejected");
                }
                else
                {
                    AssertLogger.Fail("Expected conflict error for duplicate name update, but API accepted it", "DuplicateNameUpdateAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Conflict || cex.StatusCode == (HttpStatusCode)422,
                    "Expected 409 or 422 for duplicate name update exception",
                    "DuplicateNameUpdateException");
            }
            finally
            {
                SafeDelete(firstRoleUid);
                SafeDelete(secondRoleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test032_Should_Fail_Update_Role_With_Conflicting_Rules_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test032_Should_Fail_Update_Role_With_Conflicting_Rules_Sync");
            string roleUid = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_update_conflicting_{Guid.NewGuid():N}");
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForUpdateConflicting");
                roleUid = ParseRoleUid(createResponse);
                
                // Attempt to update with conflicting rules
                var updateModel = CreateInvalidRoleModel("conflicting_rules");
                ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithConflictingRules");
                }
                else
                {
                    AssertLogger.Fail("Expected validation error for conflicting rules update, but API accepted it", "ConflictingRulesUpdateAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithConflictingRulesException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test033_Should_Fail_Update_Role_With_Invalid_Content_Type_Rules_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test033_Should_Fail_Update_Role_With_Invalid_Content_Type_Rules_Sync");
            string roleUid = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_update_invalid_ct_{Guid.NewGuid():N}");
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForUpdateInvalidCT");
                roleUid = ParseRoleUid(createResponse);
                
                // Attempt to update with invalid content type rules
                var updateModel = CreateInvalidRoleModel("invalid_content_types");
                ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithInvalidContentTypes");
                }
                else
                {
                    AssertLogger.Fail("Expected validation error for invalid content type rules, but API accepted it", "InvalidContentTypesUpdateAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithInvalidContentTypesException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test034_Should_Fail_Update_Role_With_Invalid_Environment_Rules_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test034_Should_Fail_Update_Role_With_Invalid_Environment_Rules_Sync");
            string roleUid = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_update_invalid_env_{Guid.NewGuid():N}");
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForUpdateInvalidEnv");
                roleUid = ParseRoleUid(createResponse);
                
                // Attempt to update with invalid environment rules
                var updateModel = CreateInvalidRoleModel("invalid_environments");
                ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithInvalidEnvironments");
                }
                else
                {
                    AssertLogger.Fail("Expected validation error for invalid environment rules, but API accepted it", "InvalidEnvironmentsUpdateAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithInvalidEnvironmentsException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        #endregion

        #region H — Role Update Validation Tests (Async)

        [TestMethod]
        [DoNotParallelize]
        public async Task Test035_Should_Accept_Update_Role_With_Empty_Name_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test035_Should_Accept_Update_Role_With_Empty_Name_Async");
            string roleUid = null;
            string originalName = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_update_empty_name_async_{Guid.NewGuid():N}");
                originalName = createModel.Name;
                ContentstackResponse createResponse = await _stack.Role().CreateAsync(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForUpdateEmptyNameAsync");
                roleUid = ParseRoleUid(createResponse);
                
                // Attempt to update with empty name - API preserves original name
                var updateModel = CreateInvalidRoleModel("empty_name");
                ContentstackResponse updateResponse = await _stack.Role(roleUid).UpdateAsync(updateModel);
                
                if (updateResponse.IsSuccessStatusCode)
                {
                    AssertLogger.IsTrue(true, "EmptyNameUpdateAcceptedAsync");
                    
                    // Verify API preserved original name when empty name provided
                    var role = updateResponse.OpenJsonObjectResponse()?["role"];
                    var currentName = role?["name"]?.ToString();
                    AssertLogger.AreEqual(originalName, currentName, "OriginalNamePreservedAsync");
                    AssertLogger.IsTrue(!string.IsNullOrEmpty(currentName), "NameNotEmptyAsync");
                }
                else
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithEmptyNameAsync");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithEmptyNameAsyncException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test036_Should_Fail_Update_Role_With_Null_Rules_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test036_Should_Fail_Update_Role_With_Null_Rules_Async");
            string roleUid = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_update_null_rules_async_{Guid.NewGuid():N}");
                ContentstackResponse createResponse = await _stack.Role().CreateAsync(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForUpdateNullRulesAsync");
                roleUid = ParseRoleUid(createResponse);
                
                // Attempt to update with null rules
                var updateModel = CreateInvalidRoleModel("null_rules");
                ContentstackResponse updateResponse = await _stack.Role(roleUid).UpdateAsync(updateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithNullRulesAsync");
                }
                else
                {
                    AssertLogger.Fail("Expected validation error for null rules update async, but API accepted it", "NullRulesUpdateAcceptedAsync");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithNullRulesAsyncException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test037_Should_Fail_Update_Role_To_Duplicate_Name_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test037_Should_Fail_Update_Role_To_Duplicate_Name_Async");
            string firstRoleUid = null;
            string secondRoleUid = null;
            
            try
            {
                // Create first role
                string firstName = $"role_update_duplicate_first_async_{Guid.NewGuid():N}";
                var firstModel = BuildMinimalRoleModel(firstName);
                ContentstackResponse firstResponse = await _stack.Role().CreateAsync(firstModel);
                AssertLogger.IsTrue(firstResponse.IsSuccessStatusCode, "First role creation should succeed", "FirstRoleUpdateAsyncSuccess");
                firstRoleUid = ParseRoleUid(firstResponse);
                
                // Create second role
                string secondName = $"role_update_duplicate_second_async_{Guid.NewGuid():N}";
                var secondModel = BuildMinimalRoleModel(secondName);
                ContentstackResponse secondResponse = await _stack.Role().CreateAsync(secondModel);
                AssertLogger.IsTrue(secondResponse.IsSuccessStatusCode, "Second role creation should succeed", "SecondRoleUpdateAsyncSuccess");
                secondRoleUid = ParseRoleUid(secondResponse);
                
                // Attempt to update second role to have same name as first
                var duplicateUpdateModel = BuildMinimalRoleModel(firstName);
                ContentstackResponse updateResponse = await _stack.Role(secondRoleUid).UpdateAsync(duplicateUpdateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertLogger.IsTrue(
                        updateResponse.StatusCode == HttpStatusCode.Conflict || 
                        updateResponse.StatusCode == (HttpStatusCode)422,
                        "Expected 409 Conflict or 422 for duplicate name update async",
                        "DuplicateNameUpdateRejectedAsync");
                }
                else
                {
                    AssertLogger.Fail("Expected conflict error for duplicate name update async, but API accepted it", "DuplicateNameUpdateAcceptedAsync");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Conflict || cex.StatusCode == (HttpStatusCode)422,
                    "Expected 409 or 422 for duplicate name update async exception",
                    "DuplicateNameUpdateAsyncException");
            }
            finally
            {
                SafeDelete(firstRoleUid);
                SafeDelete(secondRoleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test038_Should_Fail_Update_Role_With_Conflicting_Rules_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test038_Should_Fail_Update_Role_With_Conflicting_Rules_Async");
            string roleUid = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_update_conflicting_async_{Guid.NewGuid():N}");
                ContentstackResponse createResponse = await _stack.Role().CreateAsync(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForUpdateConflictingAsync");
                roleUid = ParseRoleUid(createResponse);
                
                // Attempt to update with conflicting rules
                var updateModel = CreateInvalidRoleModel("conflicting_rules");
                ContentstackResponse updateResponse = await _stack.Role(roleUid).UpdateAsync(updateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithConflictingRulesAsync");
                }
                else
                {
                    AssertLogger.Fail("Expected validation error for conflicting rules update async, but API accepted it", "ConflictingRulesUpdateAcceptedAsync");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithConflictingRulesAsyncException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        #endregion

        #region I — Authentication & Authorization Tests (Sync)

        [TestMethod]
        [DoNotParallelize]
        public void Test039_Should_Fail_Operations_With_Invalid_Auth_Token_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test039_Should_Fail_Operations_With_Invalid_Auth_Token_Sync");
            
            // Create a temporary client with invalid auth token
            var invalidClient = new ContentstackClient(new ContentstackClientOptions()
            {
                Host = _client.contentstackOptions.Host,
                Authtoken = "invalid_auth_token_12345"
            });
            
            var invalidStack = invalidClient.Stack(_stack.APIKey);
            
            try
            {
                var model = BuildMinimalRoleModel($"role_invalid_auth_{Guid.NewGuid():N}");
                
                AssertLogger.ThrowsException<ContentstackErrorException>(() =>
                {
                    ContentstackResponse response = invalidStack.Role().Create(model);
                    if (!response.IsSuccessStatusCode && (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden))
                    {
                        throw new ContentstackErrorException { StatusCode = response.StatusCode, ErrorMessage = "Authentication failed" };
                    }
                }, "CreateWithInvalidAuthToken");
            }
            catch (ContentstackErrorException cex)
            {
                AssertAuthenticationError(cex, "CreateWithInvalidAuthTokenException");
            }
            finally
            {
                try { invalidClient?.Logout(); } catch { }
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test040_Should_Fail_Operations_With_Malformed_API_Key_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test040_Should_Fail_Operations_With_Malformed_API_Key_Sync");
            
            // Use an invalid API key format
            var invalidStack = _client.Stack("invalid_api_key_format");
            
            try
            {
                var model = BuildMinimalRoleModel($"role_invalid_api_{Guid.NewGuid():N}");
                
                AssertLogger.ThrowsException<ContentstackErrorException>(() =>
                {
                    ContentstackResponse response = invalidStack.Role().Create(model);
                    if (!response.IsSuccessStatusCode)
                    {
                        throw new ContentstackErrorException 
                        { 
                            StatusCode = response.StatusCode, 
                            ErrorMessage = "Invalid API key" 
                        };
                    }
                }, "CreateWithInvalidAPIKey");
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Unauthorized ||
                    cex.StatusCode == HttpStatusCode.Forbidden ||
                    cex.StatusCode == HttpStatusCode.NotFound ||
                    cex.StatusCode == (HttpStatusCode)422,
                    $"Expected auth/validation error for invalid API key, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "InvalidAPIKeyError");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test041_Should_Handle_Fetch_With_Invalid_Credentials_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test041_Should_Handle_Fetch_With_Invalid_Credentials_Sync");
            
            // Create a client with invalid credentials
            var invalidClient = new ContentstackClient(new ContentstackClientOptions()
            {
                Host = _client.contentstackOptions.Host,
                Authtoken = "blt_invalid_token_format"
            });
            
            var invalidStack = invalidClient.Stack(_stack.APIKey);
            
            try
            {
                AssertLogger.ThrowsException<ContentstackErrorException>(() =>
                {
                    ContentstackResponse response = invalidStack.Role(NonExistentRoleUid).Fetch();
                    if (!response.IsSuccessStatusCode && (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden))
                    {
                        throw new ContentstackErrorException { StatusCode = response.StatusCode, ErrorMessage = "Authentication failed" };
                    }
                }, "FetchWithInvalidCredentials");
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Unauthorized ||
                    cex.StatusCode == HttpStatusCode.Forbidden ||
                    cex.StatusCode == HttpStatusCode.NotFound ||
                    cex.StatusCode == (HttpStatusCode)422,
                    $"Expected auth/validation error for invalid credentials, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "InvalidCredentialsError");
            }
            finally
            {
                try { invalidClient?.Logout(); } catch { }
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test042_Should_Handle_Update_With_Invalid_Auth_Context_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test042_Should_Handle_Update_With_Invalid_Auth_Context_Sync");
            
            // Create a client with empty/null auth token
            var invalidClient = new ContentstackClient(new ContentstackClientOptions()
            {
                Host = _client.contentstackOptions.Host,
                Authtoken = ""
            });
            
            var invalidStack = invalidClient.Stack(_stack.APIKey);
            
            try
            {
                var model = BuildMinimalRoleModel($"role_no_auth_{Guid.NewGuid():N}");
                
                AssertLogger.ThrowsException<InvalidOperationException>(() =>
                {
                    ContentstackResponse response = invalidStack.Role(NonExistentRoleUid).Update(model);
                    if (!response.IsSuccessStatusCode && (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden))
                    {
                        throw new ContentstackErrorException { StatusCode = response.StatusCode, ErrorMessage = "Authentication required" };
                    }
                }, "UpdateWithNoAuthContext");
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Unauthorized ||
                    cex.StatusCode == HttpStatusCode.Forbidden ||
                    cex.StatusCode == HttpStatusCode.BadRequest ||
                    cex.StatusCode == (HttpStatusCode)422,
                    $"Expected auth/validation error for missing auth, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "NoAuthContextError");
            }
            finally
            {
                try { invalidClient?.Logout(); } catch { }
            }
        }

        #endregion

        #region J — Authentication & Authorization Tests (Async)

        [TestMethod]
        [DoNotParallelize]
        public async Task Test043_Should_Fail_Operations_With_Invalid_Auth_Token_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test043_Should_Fail_Operations_With_Invalid_Auth_Token_Async");
            
            // Create a temporary client with invalid auth token
            var invalidClient = new ContentstackClient(new ContentstackClientOptions()
            {
                Host = _client.contentstackOptions.Host,
                Authtoken = "invalid_auth_token_async_12345"
            });
            
            var invalidStack = invalidClient.Stack(_stack.APIKey);
            
            try
            {
                var model = BuildMinimalRoleModel($"role_invalid_auth_async_{Guid.NewGuid():N}");
                
                await AssertLogger.ThrowsContentstackErrorAsync(async () =>
                {
                    ContentstackResponse response = await invalidStack.Role().CreateAsync(model);
                    if (!response.IsSuccessStatusCode && (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden))
                    {
                        throw new ContentstackErrorException { StatusCode = response.StatusCode, ErrorMessage = "Authentication failed" };
                    }
                }, "CreateWithInvalidAuthTokenAsync", HttpStatusCode.Unauthorized, HttpStatusCode.Forbidden);
            }
            catch (ContentstackErrorException cex)
            {
                AssertAuthenticationError(cex, "CreateWithInvalidAuthTokenAsyncException");
            }
            finally
            {
                try { invalidClient?.Logout(); } catch { }
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test044_Should_Fail_Operations_With_Malformed_API_Key_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test044_Should_Fail_Operations_With_Malformed_API_Key_Async");
            
            // Use an invalid API key format
            var invalidStack = _client.Stack("invalid_api_key_format_async");
            
            try
            {
                var model = BuildMinimalRoleModel($"role_invalid_api_async_{Guid.NewGuid():N}");
                
                await AssertLogger.ThrowsContentstackErrorAsync(async () =>
                {
                    ContentstackResponse response = await invalidStack.Role().CreateAsync(model);
                    if (!response.IsSuccessStatusCode)
                    {
                        throw new ContentstackErrorException 
                        { 
                            StatusCode = response.StatusCode, 
                            ErrorMessage = "Invalid API key" 
                        };
                    }
                }, "CreateWithInvalidAPIKeyAsync", HttpStatusCode.Unauthorized, HttpStatusCode.Forbidden, HttpStatusCode.NotFound, (HttpStatusCode)422, (HttpStatusCode)412);
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Unauthorized ||
                    cex.StatusCode == HttpStatusCode.Forbidden ||
                    cex.StatusCode == HttpStatusCode.NotFound ||
                    cex.StatusCode == (HttpStatusCode)422 ||
                    cex.StatusCode == (HttpStatusCode)412,
                    $"Expected auth/validation error for invalid API key async, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "InvalidAPIKeyAsyncError");
            }
        }

        #endregion

        #region K — Data Integrity & Constraint Tests (Sync)

        [TestMethod]
        [DoNotParallelize]
        public void Test045_Should_Fail_Create_Role_With_Invalid_Resource_References_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test045_Should_Fail_Create_Role_With_Invalid_Resource_References_Sync");
            
            try
            {
                // Create role with references to non-existent resources
                var invalidModel = new RoleModel
                {
                    Name = $"role_invalid_refs_{Guid.NewGuid():N}",
                    Description = "Test role with invalid resource references",
                    DeployContent = true,
                    Rules = new List<Rule>
                    {
                        new ContentTypeRules { ContentTypes = new List<string> { "nonexistent_ct_uid_12345" } },
                        new EnvironmentRules { Environments = new List<string> { "nonexistent_env_uid_12345" } },
                        new AssetRules { Assets = new List<string> { "nonexistent_asset_uid_12345" } }
                    }
                };
                
                ContentstackResponse response = _stack.Role().Create(invalidModel);
                
                if (!response.IsSuccessStatusCode)
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithInvalidResourceRefs");
                }
                else
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.Fail("Expected validation error for invalid resource references, but API accepted them", "InvalidResourceRefsAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithInvalidResourceRefsException");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test046_Should_Fail_Update_Role_With_Broken_Dependencies_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test046_Should_Fail_Update_Role_With_Broken_Dependencies_Sync");
            string roleUid = null;
            
            try
            {
                // Create a valid role first
                var createModel = BuildMinimalRoleModel($"role_broken_deps_{Guid.NewGuid():N}");
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForBrokenDeps");
                roleUid = ParseRoleUid(createResponse);
                
                // Update with broken dependencies
                var updateModel = new RoleModel
                {
                    Name = $"role_updated_broken_{Guid.NewGuid():N}",
                    Description = "Updated role with broken dependencies",
                    DeployContent = true,
                    Rules = new List<Rule>
                    {
                        new BranchRules { Branches = new List<string> { "broken_branch_ref_12345" } },
                        new FolderRules { Folders = new List<string> { "broken_folder_ref_12345" } }
                    }
                };
                
                ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                
                if (!updateResponse.IsSuccessStatusCode)
                {
                    AssertValidationError(updateResponse.StatusCode, "UpdateRoleWithBrokenDeps");
                }
                else
                {
                    AssertLogger.Fail("Expected validation error for broken dependencies, but API accepted them", "BrokenDepsAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "UpdateRoleWithBrokenDepsException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test047_Should_Fail_Create_Role_Exceeding_System_Limits_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test047_Should_Fail_Create_Role_Exceeding_System_Limits_Sync");
            
            try
            {
                // Create role with excessive rules to test system limits
                var excessiveRules = new List<Rule>();
                
                // Add many branch rules to potentially exceed limits
                for (int i = 0; i < 100; i++)
                {
                    excessiveRules.Add(new BranchRules { Branches = new List<string> { $"branch_{i}" } });
                }
                
                var limitModel = new RoleModel
                {
                    Name = $"role_system_limits_{Guid.NewGuid():N}",
                    Description = "Test role exceeding system limits",
                    DeployContent = true,
                    Rules = excessiveRules
                };
                
                ContentstackResponse response = _stack.Role().Create(limitModel);
                
                if (!response.IsSuccessStatusCode)
                {
                    AssertLogger.IsTrue(
                        response.StatusCode == (HttpStatusCode)422 ||
                        response.StatusCode == HttpStatusCode.BadRequest ||
                        response.StatusCode == (HttpStatusCode)413, // Payload Too Large
                        $"Expected validation/limit error, got {(int)response.StatusCode} ({response.StatusCode})",
                        "SystemLimitsRejected");
                }
                else
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.Fail("Expected system limit error, but API accepted excessive rules", "SystemLimitsAccepted");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == (HttpStatusCode)422 ||
                    cex.StatusCode == HttpStatusCode.BadRequest ||
                    cex.StatusCode == (HttpStatusCode)413,
                    $"Expected validation/limit error exception, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "SystemLimitsException");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test048_Should_Handle_Role_Operations_During_Maintenance_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test048_Should_Handle_Role_Operations_During_Maintenance_Sync");
            
            // This test simulates operations that might fail during system maintenance
            // In practice, this would require coordination with the backend team
            try
            {
                var model = BuildMinimalRoleModel($"role_maintenance_{Guid.NewGuid():N}");
                ContentstackResponse response = _stack.Role().Create(model);
                
                if (response.IsSuccessStatusCode)
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.IsTrue(true, "Operation succeeded - no maintenance mode detected", "MaintenanceNotDetected");
                }
                else
                {
                    // Log maintenance-related status codes
                    AssertLogger.IsTrue(
                        response.StatusCode == HttpStatusCode.ServiceUnavailable ||
                        response.StatusCode == (HttpStatusCode)503 ||
                        response.StatusCode == (HttpStatusCode)502 ||
                        (int)response.StatusCode >= 400,
                        $"Unexpected status during potential maintenance: {(int)response.StatusCode} ({response.StatusCode})",
                        "MaintenanceHandling");
                }
            }
            catch (ContentstackErrorException cex)
            {
                // Document maintenance-related errors
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.ServiceUnavailable ||
                    cex.StatusCode == (HttpStatusCode)503 ||
                    cex.StatusCode == (HttpStatusCode)502 ||
                    (int)cex.StatusCode >= 400,
                    $"Maintenance error handling: {(int)cex.StatusCode} ({cex.StatusCode})",
                    "MaintenanceException");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test049_Should_Validate_Role_Stack_Isolation_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test049_Should_Validate_Role_Stack_Isolation_Sync");
            
            try
            {
                // Attempt to access role using different stack context
                var differentStackKey = "blt_fake_stack_key_12345";
                var differentStack = _client.Stack(differentStackKey);
                
                var model = BuildMinimalRoleModel($"role_stack_isolation_{Guid.NewGuid():N}");
                
                AssertLogger.ThrowsException<ContentstackErrorException>(() =>
                {
                    ContentstackResponse response = differentStack.Role().Create(model);
                    if (!response.IsSuccessStatusCode)
                    {
                        throw new ContentstackErrorException 
                        { 
                            StatusCode = response.StatusCode, 
                            ErrorMessage = "Stack isolation failure" 
                        };
                    }
                }, "CreateRoleStackIsolation");
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Unauthorized ||
                    cex.StatusCode == HttpStatusCode.Forbidden ||
                    cex.StatusCode == HttpStatusCode.NotFound ||
                    cex.StatusCode == (HttpStatusCode)422,
                    $"Expected auth/validation error for stack isolation, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "StackIsolationError");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test050_Should_Fail_Delete_Role_With_Active_Dependencies_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test050_Should_Fail_Delete_Role_With_Active_Dependencies_Sync");
            string roleUid = null;
            
            try
            {
                // Create a role that might have dependencies
                var model = BuildMinimalRoleModel($"role_with_dependencies_{Guid.NewGuid():N}");
                ContentstackResponse createResponse = _stack.Role().Create(model);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForDependencies");
                roleUid = ParseRoleUid(createResponse);
                
                // In a real scenario, this role would be assigned to users or have other dependencies
                // For this test, we simulate the delete and check if the API properly handles dependencies
                
                ContentstackResponse deleteResponse = _stack.Role(roleUid).Delete();
                
                if (deleteResponse.IsSuccessStatusCode)
                {
                    // Role was deleted successfully (no active dependencies)
                    roleUid = null; // Mark as deleted to prevent double cleanup
                    AssertLogger.IsTrue(true, "Role deleted successfully - no active dependencies", "NoDependencies");
                }
                else
                {
                    // API rejected deletion due to dependencies
                    AssertLogger.IsTrue(
                        deleteResponse.StatusCode == HttpStatusCode.Conflict ||
                        deleteResponse.StatusCode == (HttpStatusCode)422 ||
                        deleteResponse.StatusCode == HttpStatusCode.BadRequest,
                        $"Expected conflict/validation error for dependencies, got {(int)deleteResponse.StatusCode} ({deleteResponse.StatusCode})",
                        "DependenciesBlocked");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Conflict ||
                    cex.StatusCode == (HttpStatusCode)422 ||
                    cex.StatusCode == HttpStatusCode.BadRequest,
                    $"Expected conflict/validation error for dependencies exception, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "DependenciesException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        #endregion

        #region L — Data Integrity & Constraint Tests (Async)

        [TestMethod]
        [DoNotParallelize]
        public async Task Test051_Should_Fail_Create_Role_With_Invalid_Resource_References_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test051_Should_Fail_Create_Role_With_Invalid_Resource_References_Async");
            
            try
            {
                // Create role with references to non-existent resources
                var invalidModel = new RoleModel
                {
                    Name = $"role_invalid_refs_async_{Guid.NewGuid():N}",
                    Description = "Test role with invalid resource references async",
                    DeployContent = true,
                    Rules = new List<Rule>
                    {
                        new ContentTypeRules { ContentTypes = new List<string> { "nonexistent_ct_uid_async_12345" } },
                        new EnvironmentRules { Environments = new List<string> { "nonexistent_env_uid_async_12345" } }
                    }
                };
                
                ContentstackResponse response = await _stack.Role().CreateAsync(invalidModel);
                
                if (!response.IsSuccessStatusCode)
                {
                    AssertValidationError(response.StatusCode, "CreateRoleWithInvalidResourceRefsAsync");
                }
                else
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.Fail("Expected validation error for invalid resource references async, but API accepted them", "InvalidResourceRefsAcceptedAsync");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "CreateRoleWithInvalidResourceRefsAsyncException");
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test052_Should_Validate_Role_Stack_Isolation_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test052_Should_Validate_Role_Stack_Isolation_Async");
            
            try
            {
                // Attempt to access role using different stack context
                var differentStackKey = "blt_fake_stack_key_async_12345";
                var differentStack = _client.Stack(differentStackKey);
                
                var model = BuildMinimalRoleModel($"role_stack_isolation_async_{Guid.NewGuid():N}");
                
                await AssertLogger.ThrowsContentstackErrorAsync(async () =>
                {
                    ContentstackResponse response = await differentStack.Role().CreateAsync(model);
                    if (!response.IsSuccessStatusCode)
                    {
                        throw new ContentstackErrorException 
                        { 
                            StatusCode = response.StatusCode, 
                            ErrorMessage = "Stack isolation failure async" 
                        };
                    }
                }, "CreateRoleStackIsolationAsync", HttpStatusCode.Unauthorized, HttpStatusCode.Forbidden, HttpStatusCode.NotFound, (HttpStatusCode)422, (HttpStatusCode)412);
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == HttpStatusCode.Unauthorized ||
                    cex.StatusCode == HttpStatusCode.Forbidden ||
                    cex.StatusCode == HttpStatusCode.NotFound ||
                    cex.StatusCode == (HttpStatusCode)422 ||
                    cex.StatusCode == (HttpStatusCode)412,
                    $"Expected auth/validation error for stack isolation async, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "StackIsolationAsyncError");
            }
        }

        #endregion

        #region M — Edge Cases & Boundary Tests (Sync)

        [TestMethod]
        [DoNotParallelize]
        public void Test053_Should_Handle_Large_Role_Payload_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test053_Should_Handle_Large_Role_Payload_Sync");
            string roleUid = null;
            
            try
            {
                // Create a role with large description and many rules
                var largeDescription = new string('A', 5000); // 5KB description
                var manyRules = new List<Rule>();
                
                // Add multiple rule types with large content
                for (int i = 0; i < 10; i++)
                {
                    manyRules.Add(new BranchRules { Branches = new List<string> { $"branch_{i}_{new string('b', 100)}" } });
                    manyRules.Add(new ContentTypeRules { ContentTypes = new List<string> { $"ct_{i}_{new string('c', 100)}" } });
                }
                
                var largeModel = new RoleModel
                {
                    Name = $"role_large_payload_{Guid.NewGuid():N}",
                    Description = largeDescription,
                    DeployContent = true,
                    Rules = manyRules
                };
                
                ContentstackResponse response = _stack.Role().Create(largeModel);
                
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "LargePayloadAccepted");
                }
                else
                {
                    AssertLogger.IsTrue(
                        response.StatusCode == (HttpStatusCode)413 || // Payload Too Large
                        response.StatusCode == (HttpStatusCode)422 ||
                        response.StatusCode == HttpStatusCode.BadRequest,
                        $"Expected payload size error, got {(int)response.StatusCode} ({response.StatusCode})",
                        "LargePayloadRejected");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == (HttpStatusCode)413 ||
                    cex.StatusCode == (HttpStatusCode)422 ||
                    cex.StatusCode == HttpStatusCode.BadRequest,
                    $"Expected payload size error exception, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "LargePayloadException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test054_Should_Handle_Unicode_Characters_In_Role_Name_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test054_Should_Handle_Unicode_Characters_In_Role_Name_Sync");
            string roleUid = null;
            
            try
            {
                // Test various Unicode characters
                string unicodeName = $"role_unicode_测试_🚀_émojis_{Guid.NewGuid():N}";
                
                var unicodeModel = new RoleModel
                {
                    Name = unicodeName,
                    Description = "Role with Unicode characters: 中文, Émojis 🎉, and special chars ñáéíóú",
                    DeployContent = true,
                    Rules = new List<Rule>
                    {
                        new BranchRules { Branches = new List<string> { "main" } }
                    }
                };
                
                ContentstackResponse response = _stack.Role().Create(unicodeModel);
                
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "UnicodeAccepted");
                    
                    // Verify the Unicode characters are preserved
                    ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch();
                    if (fetchResponse.IsSuccessStatusCode)
                    {
                        var role = fetchResponse.OpenJsonObjectResponse()?["role"];
                        var fetchedName = role?["name"]?.ToString();
                        AssertLogger.AreEqual(unicodeName, fetchedName, "Unicode name should be preserved", "UnicodePreserved");
                    }
                }
                else
                {
                    AssertValidationError(response.StatusCode, "UnicodeRejected");
                }
            }
            catch (ContentstackErrorException cex)
            {
                // Document encoding-related errors
                AssertLogger.IsTrue(
                    (int)cex.StatusCode >= 400 && (int)cex.StatusCode < 500,
                    $"Unicode handling error: {(int)cex.StatusCode} ({cex.StatusCode})",
                    "UnicodeException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test055_Should_Handle_Special_Character_Encoding_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test055_Should_Handle_Special_Character_Encoding_Sync");
            string roleUid = null;
            
            try
            {
                // Test various special characters that might cause encoding issues
                string specialName = $"role_special_<>&\\\"'{{}}[]()_{Guid.NewGuid():N}";
                
                var specialModel = new RoleModel
                {
                    Name = specialName,
                    Description = "Special chars: <script>alert('xss')</script> & \\\"quotes\\\" & 'single' & {{json}} & [array]",
                    DeployContent = true,
                    Rules = new List<Rule>
                    {
                        new BranchRules { Branches = new List<string> { "main" } }
                    }
                };
                
                ContentstackResponse response = _stack.Role().Create(specialModel);
                
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "SpecialCharsAccepted");
                }
                else
                {
                    AssertValidationError(response.StatusCode, "SpecialCharsRejected");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertValidationError(cex.StatusCode, "SpecialCharsException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test056_Should_Handle_Stack_Role_Limits_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test056_Should_Handle_Stack_Role_Limits_Sync");
            
            // This test creates roles until hitting the stack role limit (Error Code 157)
            var createdRoles = new List<string>();
            
            try
            {
                for (int i = 0; i < 20; i++) // Increase limit to potentially hit stack role limit
                {
                    var model = BuildMinimalRoleModel($"role_stack_limit_{i}_{Guid.NewGuid():N}");
                    
                    try
                    {
                        ContentstackResponse response = _stack.Role().Create(model);
                        
                        if (response.IsSuccessStatusCode)
                        {
                            var roleUid = ParseRoleUid(response);
                            createdRoles.Add(roleUid);
                        }
                        else if (response.StatusCode == (HttpStatusCode)422) // Unprocessable Entity
                        {
                            // Check for role limit error (Error Code 157)
                            var errorContent = response.OpenJsonObjectResponse();
                            var errorCode = errorContent?["error_code"]?.ToString();
                            
                            if (errorCode == "157")
                            {
                                AssertLogger.IsTrue(true, "Stack role limit detected and handled", "StackRoleLimitDetected");
                                break;
                            }
                            else
                            {
                                TestOutputLogger.LogContext("StackLimitTest", $"Request {i} failed with 422 but error code: {errorCode}");
                            }
                        }
                        else if (!response.IsSuccessStatusCode)
                        {
                            // Log other errors but continue
                            TestOutputLogger.LogContext("StackLimitTest", $"Request {i} failed with {response.StatusCode}");
                        }
                    }
                    catch (ContentstackErrorException cex) when (cex.StatusCode == (HttpStatusCode)422)
                    {
                        // Check for role limit error code in exception
                        if (cex.ErrorCode == 157 || cex.ErrorMessage?.Contains("157") == true)
                        {
                            AssertLogger.IsTrue(true, "Stack role limit exception handled", "StackRoleLimitException");
                            break;
                        }
                        else
                        {
                            TestOutputLogger.LogContext("StackLimitTest", $"422 exception but different error: {cex.ErrorCode} - {cex.ErrorMessage}");
                        }
                    }
                }
                
                AssertLogger.IsTrue(true, "Stack role limit test completed", "StackRoleLimitCompleted");
            }
            finally
            {
                // Clean up all created roles
                foreach (var roleUid in createdRoles)
                {
                    SafeDelete(roleUid);
                }
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test057_Should_Handle_Network_Timeout_Scenarios_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test057_Should_Handle_Network_Timeout_Scenarios_Sync");
            
            try
            {
                // Create a role with a potentially slow operation
                var model = BuildMinimalRoleModel($"role_timeout_test_{Guid.NewGuid():N}");
                
                ContentstackResponse response = _stack.Role().Create(model);
                
                if (response.IsSuccessStatusCode)
                {
                    var roleUid = ParseRoleUid(response);
                    SafeDelete(roleUid);
                    AssertLogger.IsTrue(true, "Operation completed within timeout", "NoTimeoutDetected");
                }
                else
                {
                    AssertLogger.IsTrue(
                        response.StatusCode == HttpStatusCode.RequestTimeout ||
                        response.StatusCode == HttpStatusCode.GatewayTimeout ||
                        (int)response.StatusCode >= 500,
                        $"Timeout handling: {(int)response.StatusCode} ({response.StatusCode})",
                        "TimeoutHandled");
                }
            }
            catch (ContentstackErrorException cex) when (
                cex.StatusCode == HttpStatusCode.RequestTimeout ||
                cex.StatusCode == HttpStatusCode.GatewayTimeout)
            {
                AssertLogger.IsTrue(true, "Timeout exception handled properly", "TimeoutException");
            }
            catch (Exception ex)
            {
                // Handle other network-related exceptions
                AssertLogger.IsTrue(
                    ex.Message.Contains("timeout") || ex.Message.Contains("Timeout"),
                    $"Network exception handled: {ex.GetType().Name}: {ex.Message}",
                    "NetworkException");
            }
        }

        #endregion

        #region N — Edge Cases & Boundary Tests (Async)

        [TestMethod]
        [DoNotParallelize]
        public async Task Test058_Should_Handle_Large_Role_Payload_Async()
        {
            TestOutputLogger.LogContext("TestScenario", "Test058_Should_Handle_Large_Role_Payload_Async");
            string roleUid = null;
            
            try
            {
                // Create a role with large description and many rules
                var largeDescription = new string('A', 5000); // 5KB description
                var manyRules = new List<Rule>();
                
                // Add multiple rule types with large content
                for (int i = 0; i < 10; i++)
                {
                    manyRules.Add(new BranchRules { Branches = new List<string> { $"branch_async_{i}_{new string('b', 100)}" } });
                }
                
                var largeModel = new RoleModel
                {
                    Name = $"role_large_payload_async_{Guid.NewGuid():N}",
                    Description = largeDescription,
                    DeployContent = true,
                    Rules = manyRules
                };
                
                ContentstackResponse response = await _stack.Role().CreateAsync(largeModel);
                
                if (response.IsSuccessStatusCode)
                {
                    roleUid = ParseRoleUid(response);
                    AssertLogger.IsNotNull(roleUid, "LargePayloadAcceptedAsync");
                }
                else
                {
                    AssertLogger.IsTrue(
                        response.StatusCode == (HttpStatusCode)413 || // Payload Too Large
                        response.StatusCode == (HttpStatusCode)422 ||
                        response.StatusCode == HttpStatusCode.BadRequest,
                        $"Expected payload size error async, got {(int)response.StatusCode} ({response.StatusCode})",
                        "LargePayloadRejectedAsync");
                }
            }
            catch (ContentstackErrorException cex)
            {
                AssertLogger.IsTrue(
                    cex.StatusCode == (HttpStatusCode)413 ||
                    cex.StatusCode == (HttpStatusCode)422 ||
                    cex.StatusCode == HttpStatusCode.BadRequest,
                    $"Expected payload size error async exception, got {(int)cex.StatusCode} ({cex.StatusCode})",
                    "LargePayloadAsyncException");
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        #endregion

        #region O — Concurrent Operations & Race Conditions Tests (Sync)

        [TestMethod]
        [DoNotParallelize]
        public void Test059_Should_Handle_Concurrent_Role_Modifications_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test059_Should_Handle_Concurrent_Role_Modifications_Sync");
            string roleUid = null;
            
            try
            {
                // Create a role for concurrent modification testing
                var originalName = $"role_concurrent_mod_{Guid.NewGuid():N}";
                var createModel = BuildMinimalRoleModel(originalName);
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForConcurrent");
                roleUid = ParseRoleUid(createResponse);
                
                // Simulate concurrent modifications
                var exceptions = new List<Exception>();
                var updateTasks = new List<System.Threading.Tasks.Task>();
                
                for (int i = 0; i < 3; i++)
                {
                    int taskId = i;
                    var task = System.Threading.Tasks.Task.Run(() =>
                    {
                        try
                        {
                            var updateModel = BuildMinimalRoleModel($"{originalName}_update_{taskId}");
                            updateModel.Description = $"Concurrent update {taskId} at {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss.fff}";
                            
                            ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                            
                            if (!updateResponse.IsSuccessStatusCode)
                            {
                                TestOutputLogger.LogContext("ConcurrentTest", $"Update {taskId} failed with {updateResponse.StatusCode}");
                            }
                        }
                        catch (Exception ex)
                        {
                            lock (exceptions)
                            {
                                exceptions.Add(ex);
                            }
                        }
                    });
                    
                    updateTasks.Add(task);
                }
                
                // Wait for all concurrent updates to complete
                System.Threading.Tasks.Task.WaitAll(updateTasks.ToArray(), TimeSpan.FromSeconds(30));
                
                // Verify final state and log concurrent behavior
                ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch();
                if (fetchResponse.IsSuccessStatusCode)
                {
                    var role = fetchResponse.OpenJsonObjectResponse()?["role"];
                    AssertLogger.IsNotNull(role, "ConcurrentFinalState");
                }
                
                // Document any concurrent access exceptions
                if (exceptions.Count > 0)
                {
                    foreach (var ex in exceptions)
                    {
                        if (ex is ContentstackErrorException cex)
                        {
                            TestOutputLogger.LogContext("ConcurrentExceptions", $"Concurrent error: {cex.StatusCode} - {cex.ErrorMessage}");
                        }
                    }
                }
                
                AssertLogger.IsTrue(true, "Concurrent modification test completed", "ConcurrentCompleted");
            }
            catch (Exception ex)
            {
                FailWithError("ConcurrentModifications", ex);
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test060_Should_Handle_Race_Conditions_In_Role_State_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test060_Should_Handle_Race_Conditions_In_Role_State_Sync");
            string roleUid = null;
            
            try
            {
                // Create a role for race condition testing
                var baseName = $"role_race_condition_{Guid.NewGuid():N}";
                var createModel = BuildMinimalRoleModel(baseName);
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForRace");
                roleUid = ParseRoleUid(createResponse);
                
                // Simulate race condition: rapid sequence of operations
                var operations = new List<System.Threading.Tasks.Task>();
                var results = new List<string>();
                
                // Rapid fetch operations
                for (int i = 0; i < 5; i++)
                {
                    int taskId = i;
                    var fetchTask = System.Threading.Tasks.Task.Run(() =>
                    {
                        try
                        {
                            ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch();
                            lock (results)
                            {
                                results.Add($"Fetch {taskId}: {fetchResponse.StatusCode}");
                            }
                        }
                        catch (Exception ex)
                        {
                            lock (results)
                            {
                                results.Add($"Fetch {taskId} Exception: {ex.Message}");
                            }
                        }
                    });
                    
                    operations.Add(fetchTask);
                }
                
                // Rapid update operations
                for (int i = 0; i < 3; i++)
                {
                    int taskId = i;
                    var updateTask = System.Threading.Tasks.Task.Run(() =>
                    {
                        try
                        {
                            var updateModel = BuildMinimalRoleModel($"{baseName}_race_{taskId}");
                            ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                            lock (results)
                            {
                                results.Add($"Update {taskId}: {updateResponse.StatusCode}");
                            }
                        }
                        catch (Exception ex)
                        {
                            lock (results)
                            {
                                results.Add($"Update {taskId} Exception: {ex.Message}");
                            }
                        }
                    });
                    
                    operations.Add(updateTask);
                }
                
                // Wait for all operations to complete
                System.Threading.Tasks.Task.WaitAll(operations.ToArray(), TimeSpan.FromSeconds(30));
                
                // Log race condition results
                foreach (var result in results)
                {
                    TestOutputLogger.LogContext("RaceResults", result);
                }
                
                AssertLogger.IsTrue(true, "Race condition test completed", "RaceConditionCompleted");
            }
            catch (Exception ex)
            {
                FailWithError("RaceConditions", ex);
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test061_Should_Handle_Simultaneous_Create_Delete_Operations_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test061_Should_Handle_Simultaneous_Create_Delete_Operations_Sync");
            
            var createdRoles = new List<string>();
            var operationResults = new List<string>();
            
            try
            {
                // Simulate simultaneous create and delete operations
                var operations = new List<System.Threading.Tasks.Task>();
                
                // Create multiple roles simultaneously
                for (int i = 0; i < 5; i++)
                {
                    int taskId = i;
                    var createTask = System.Threading.Tasks.Task.Run(() =>
                    {
                        try
                        {
                            var model = BuildMinimalRoleModel($"role_simultaneous_create_{taskId}_{Guid.NewGuid():N}");
                            ContentstackResponse createResponse = _stack.Role().Create(model);
                            
                            if (createResponse.IsSuccessStatusCode)
                            {
                                var roleUid = ParseRoleUid(createResponse);
                                lock (createdRoles)
                                {
                                    createdRoles.Add(roleUid);
                                    operationResults.Add($"Create {taskId}: SUCCESS ({roleUid})");
                                }
                            }
                            else
                            {
                                lock (operationResults)
                                {
                                    operationResults.Add($"Create {taskId}: FAILED ({createResponse.StatusCode})");
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            lock (operationResults)
                            {
                                operationResults.Add($"Create {taskId}: EXCEPTION ({ex.Message})");
                            }
                        }
                    });
                    
                    operations.Add(createTask);
                }
                
                // Wait for creates to complete
                System.Threading.Tasks.Task.WaitAll(operations.ToArray(), TimeSpan.FromSeconds(30));
                
                // Now simulate simultaneous deletes
                var deleteOperations = new List<System.Threading.Tasks.Task>();
                var rolesToDelete = new List<string>();
                
                lock (createdRoles)
                {
                    rolesToDelete.AddRange(createdRoles);
                    createdRoles.Clear(); // Clear to prevent double cleanup
                }
                
                for (int i = 0; i < rolesToDelete.Count; i++)
                {
                    int taskId = i;
                    string roleUid = rolesToDelete[i];
                    
                    var deleteTask = System.Threading.Tasks.Task.Run(() =>
                    {
                        try
                        {
                            ContentstackResponse deleteResponse = _stack.Role(roleUid).Delete();
                            lock (operationResults)
                            {
                                operationResults.Add($"Delete {taskId}: {deleteResponse.StatusCode}");
                            }
                        }
                        catch (Exception ex)
                        {
                            lock (operationResults)
                            {
                                operationResults.Add($"Delete {taskId}: EXCEPTION ({ex.Message})");
                            }
                        }
                    });
                    
                    deleteOperations.Add(deleteTask);
                }
                
                // Wait for deletes to complete
                System.Threading.Tasks.Task.WaitAll(deleteOperations.ToArray(), TimeSpan.FromSeconds(30));
                
                // Log all operation results
                foreach (var result in operationResults)
                {
                    TestOutputLogger.LogContext("SimultaneousOps", result);
                }
                
                AssertLogger.IsTrue(true, "Simultaneous create/delete test completed", "SimultaneousOpsCompleted");
            }
            catch (Exception ex)
            {
                FailWithError("SimultaneousOperations", ex);
            }
            finally
            {
                // Clean up any remaining roles
                foreach (var roleUid in createdRoles)
                {
                    SafeDelete(roleUid);
                }
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test062_Should_Handle_Role_Locking_Conflicts_Sync()
        {
            TestOutputLogger.LogContext("TestScenario", "Test062_Should_Handle_Role_Locking_Conflicts_Sync");
            string roleUid = null;
            
            try
            {
                // Create a role for locking conflict testing
                var lockingName = $"role_locking_conflict_{Guid.NewGuid():N}";
                var createModel = BuildMinimalRoleModel(lockingName);
                ContentstackResponse createResponse = _stack.Role().Create(createModel);
                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Create role should succeed", "CreateForLocking");
                roleUid = ParseRoleUid(createResponse);
                
                // Simulate potential locking conflicts with rapid sequential operations
                var conflictResults = new List<string>();
                
                for (int i = 0; i < 10; i++)
                {
                    try
                    {
                        // Rapid sequence: fetch -> update -> fetch
                        ContentstackResponse fetchResponse1 = _stack.Role(roleUid).Fetch();
                        
                        var updateModel = BuildMinimalRoleModel($"{lockingName}_lock_test_{i}");
                        ContentstackResponse updateResponse = _stack.Role(roleUid).Update(updateModel);
                        
                        ContentstackResponse fetchResponse2 = _stack.Role(roleUid).Fetch();
                        
                        conflictResults.Add($"Sequence {i}: Fetch1({fetchResponse1.StatusCode}) -> Update({updateResponse.StatusCode}) -> Fetch2({fetchResponse2.StatusCode})");
                        
                        // Brief pause to allow for potential lock releases
                        System.Threading.Thread.Sleep(50);
                    }
                    catch (ContentstackErrorException cex)
                    {
                        // Document locking-related errors
                        conflictResults.Add($"Sequence {i}: CONFLICT ({cex.StatusCode} - {cex.ErrorMessage})");
                        
                        if (cex.StatusCode == HttpStatusCode.Conflict || 
                            cex.StatusCode == (HttpStatusCode)423) // Locked
                        {
                            TestOutputLogger.LogContext("LockingConflict", $"Detected locking conflict: {cex.StatusCode}");
                        }
                    }
                    catch (Exception ex)
                    {
                        conflictResults.Add($"Sequence {i}: EXCEPTION ({ex.GetType().Name}: {ex.Message})");
                    }
                }
                
                // Log all conflict results
                foreach (var result in conflictResults)
                {
                    TestOutputLogger.LogContext("LockingResults", result);
                }
                
                AssertLogger.IsTrue(true, "Locking conflict test completed", "LockingConflictCompleted");
            }
            catch (Exception ex)
            {
                FailWithError("LockingConflicts", ex);
            }
            finally
            {
                SafeDelete(roleUid);
            }
        }

        #endregion
    }
}