From ca06d6b62146537e97ca238135bc9cbd18fea20b Mon Sep 17 00:00:00 2001 From: OMpawar-21 Date: Mon, 11 May 2026 17:16:30 +0530 Subject: [PATCH 01/70] feat: Migration changes --- COMPREHENSIVE_MIGRATION_GUIDE.md | 942 ++++++++++++++++++ .../Contentstack.Management.Core.Tests.csproj | 3 +- .../Contentstack.cs | 49 +- .../GlobalUsings.cs | 4 + .../Helpers/ContentTypeFixtureLoader.cs | 18 +- .../Helpers/MockHttpStatusHandler.cs | 4 +- .../Helpers/TestOutputLogger.cs | 4 +- .../Contentstack001_LoginTest.cs | 25 +- .../Contentstack002_OrganisationTest.cs | 54 +- .../Contentstack003_StackTest.cs | 26 +- .../Contentstack004_ReleaseTest.cs | 55 +- .../Contentstack011_GlobalFieldTest.cs | 10 +- .../Contentstack012_ContentTypeTest.cs | 11 +- .../Contentstack012_NestedGlobalFieldTest.cs | 6 +- ...012b_ContentTypeExpandedIntegrationTest.cs | 40 +- .../Contentstack013_AssetTest.cs | 220 ++-- .../Contentstack014_EntryTest.cs | 198 ++-- .../Contentstack015_BulkOperationTest.cs | 123 ++- .../Contentstack016_DeliveryTokenTest.cs | 96 +- .../Contentstack017_TaxonomyTest.cs | 30 +- .../Contentstack018_EnvironmentTest.cs | 34 +- .../Contentstack019_RoleTest.cs | 44 +- .../Contentstack020_WorkflowTest.cs | 176 ++-- .../Contentstack021_EntryVariantTest.cs | 30 +- .../Contentstack022_VariantGroupTest.cs | 22 +- .../Model/Models.cs | 25 +- .../Model/MultiPageEntry.cs | 16 +- .../Model/PageJSONRTE.cs | 10 +- .../Model/SinglePageEntry.cs | 16 +- .../Model/StackModel.cs | 15 +- .../Model/StackSettingsModel.cs | 4 +- .../Core/ContentstackClientTest.cs | 2 +- .../Core/Services/ContentstackServiceTest.cs | 19 +- .../Models/CreateUpdateFolderServiceTest.cs | 3 +- .../Models/CreateUpdateServiceTest.cs | 3 +- .../Core/Services/Models/DeleteServiceTest.cs | 3 +- .../Services/Models/FetchDeleteServiceTest.cs | 3 +- .../Models/FetchReferencesServiceTest.cs | 3 +- .../Core/Services/Models/LocaleServiceTest.cs | 3 +- .../Models/LocalizationServiceTest.cs | 3 +- .../Models/PublishUnpublishServiceTest.cs | 3 +- .../Core/Services/Models/UploadServiceTest.cs | 3 +- .../Organization/GetOrganizationsTest.cs | 3 +- .../Services/Organization/OrgRolesTest.cs | 3 +- .../OrganizationStackServiceTest.cs | 3 +- .../ResendInvitationServiceTest.cs | 3 +- .../TransferOwnershipServiceTest.cs | 3 +- .../Organization/UserInvitationServiceTest.cs | 3 +- .../Core/Services/QueryServiceTest.cs | 1 - .../Services/Stack/BulkAddItemsServiceTest.cs | 3 +- .../Services/Stack/BulkDeleteServiceTest.cs | 8 +- .../Stack/BulkJobStatusServiceTest.cs | 8 +- .../Services/Stack/BulkPublishServiceTest.cs | 8 +- .../Stack/BulkReleaseItemsServiceTest.cs | 8 +- .../Stack/BulkUnpublishServiceTest.cs | 8 +- .../Stack/BulkUpdateItemsServiceTest.cs | 8 +- .../Stack/BulkWorkflowUpdateServiceTest.cs | 8 +- .../Services/Stack/FetchStackServiceTest.cs | 3 +- .../Stack/StackCreateUpdateServiceTest.cs | 3 +- .../Stack/StackOwnershipServiceTest.cs | 3 +- .../Stack/StackSettingsServiceTest.cs | 5 +- .../Services/Stack/StackShareServiceTest.cs | 3 +- .../User/ForgotPasswordServiceTest.cs | 3 +- .../Core/Services/User/GetLoggedinUserTest.cs | 3 +- .../Core/Services/User/LoginServiceTest.cs | 3 +- .../Core/Services/User/LogoutServiceTest.cs | 3 +- .../Services/User/ResetPasswordServiceTest.cs | 3 +- .../GlobalUsings.cs | 3 + .../Http/ContentstackHttpRequestTest.cs | 18 +- .../Http/ContentstackHttpResponseTest.cs | 2 +- .../Models/AssetTest.cs | 36 +- .../Models/AuditLogTest.cs | 8 +- .../Models/BaseModelTest.cs | 31 +- .../BulkOperation/BulkOperationModelsTest.cs | 37 +- .../BulkOperation/BulkOperationsUnitTest.cs | 55 +- .../Models/BulkReleaseItemsTest.cs | 11 +- .../ContentModel/ContentModellingTest.cs | 32 +- .../Models/ContentModel/EntryModel.cs | 5 +- .../ContentModellingNestedGlobalFieldTest.cs | 12 +- .../Models/ContentTypeTest.cs | 35 +- .../Models/CustomExtensionTest.cs | 1 - .../Models/DeliveryTokenTest.cs | 20 +- .../Models/EntryTest.cs | 63 +- .../Models/EntryVariantTest.cs | 8 +- .../Models/EnvironmentTest.cs | 20 +- .../Models/ExtensionModelTest.cs | 31 +- .../Models/ExtensionTest.cs | 24 +- .../GlobalFieldReferenceSerializationTest.cs | 27 +- .../Models/Fields/GlobalFieldReferenceTest.cs | 5 +- .../GlobalFieldReferenceValidationTest.cs | 32 +- .../Models/FolderTest.cs | 16 +- .../GlobalFieldRefsSerializationTest.cs | 38 +- .../Models/GlobalFieldRefsTest.cs | 9 +- .../Models/GlobalFieldTest.cs | 44 +- .../Models/LabelTest.cs | 20 +- .../Models/LocaleTest.cs | 20 +- .../Models/OrganizationTest.cs | 38 +- .../Models/PublishQueueTest.cs | 12 +- .../Models/PublishRuleTest.cs | 20 +- .../Models/ReleaseItemTest.cs | 16 +- .../Models/ReleaseTest.cs | 56 +- .../Models/RoleTest.cs | 24 +- .../Models/StackTest.cs | 104 +- .../Models/TaxonomyTest.cs | 15 +- .../Models/TermTest.cs | 16 +- .../Models/UserTest.cs | 28 +- .../Models/VariantGroupTest.cs | 40 +- .../Models/WebhookTest.cs | 32 +- .../Models/WorkflowTest.cs | 32 +- .../Mokes/CustomJsonConverter.cs | 39 +- .../Mokes/MockHttpHandlerWithRetries.cs | 8 +- .../Mokes/MockHttpResponse.cs | 24 +- .../Mokes/MockResponse.cs | 9 +- .../Mokes/MockService.cs | 42 +- .../Mokes/Model/StackModel.cs | 11 +- .../Queryable/ParameterCollectionTest.cs | 8 +- .../Runtime/Contexts/ContextTest.cs | 4 +- .../Services/BulkOperationServicesTest.cs | 45 +- .../GlobalFieldFetchDeleteServiceTest.cs | 29 +- .../Services/Models/GlobalFieldServiceTest.cs | 21 +- .../VariantContentTypeLinkServiceTest.cs | 107 +- .../TestJsonSerializerOptions.cs | 28 + .../Utils/ContentstackUtilitiesTest.cs | 13 +- .../Utils/NodeJsonConverterTest.cs | 78 +- .../Utils/TextNodeJsonConverterTest.cs | 67 +- .../Utils/Utilities.cs | 8 +- .../Abstractions/IEntry.cs | 7 +- .../ContentstackClient.cs | 35 +- .../ContentstackResponse.cs | 20 +- .../Exceptions/ContentstackErrorException.cs | 14 +- .../Http/ContentstackHttpRequest.cs | 12 +- Contentstack.Management.Core/IResponse.cs | 4 +- Contentstack.Management.Core/Models/Asset.cs | 28 +- .../Models/AuditLog.cs | 8 +- .../Models/BaseModel.cs | 18 +- .../Models/BulkOperation.cs | 40 +- .../Models/BulkOperationModels.cs | 136 ++- .../Models/ContentModelling.cs | 36 +- .../CustomExtension/CustomWidgetModel.cs | 19 +- Contentstack.Management.Core/Models/Entry.cs | 54 +- .../Models/EntryVariant.cs | 12 +- .../Models/EntryWorkflowStage.cs | 48 +- .../Models/EnvironmentModel.cs | 21 +- .../Models/Extension.cs | 20 +- .../Models/ExtensionModel.cs | 25 +- .../Models/Fields/DateField.cs | 6 +- .../Models/Fields/ExtensionField.cs | 6 +- .../Models/Fields/Field.cs | 21 +- .../Models/Fields/FieldMetadata.cs | 32 +- .../Models/Fields/FieldRules.cs | 20 +- .../Models/Fields/FileField.cs | 16 +- .../Models/Fields/GlobalFieldReference.cs | 23 +- .../Models/Fields/GroupField.cs | 8 +- .../Models/Fields/JsonField.cs | 4 +- .../Models/Fields/ModularBlockField.cs | 14 +- .../Models/Fields/NumberField.cs | 6 +- .../Models/Fields/ReferenceField.cs | 6 +- .../Models/Fields/SelectField.cs | 8 +- .../Models/Fields/TaxonomyField.cs | 14 +- .../Models/Fields/TextboxField.cs | 6 +- Contentstack.Management.Core/Models/Folder.cs | 16 +- .../Models/GlobalField.cs | 16 +- .../Models/GlobalFieldRefs.cs | 10 +- .../Models/LabelModel.cs | 13 +- .../Models/LocaleModel.cs | 11 +- Contentstack.Management.Core/Models/Node.cs | 3 - .../Models/OAuthAppAuthorizationResponse.cs | 10 +- .../Models/OAuthResponse.cs | 12 +- .../Models/Organization.cs | 32 +- .../Models/PublishQueue.cs | 12 +- .../Models/PublishRule.cs | 4 +- .../Models/PublishRuleModel.cs | 30 +- .../Models/PublishUnpublishDetails.cs | 1 - .../Models/PublishVariant.cs | 6 +- .../Models/PublishVariantRules.cs | 6 +- .../Models/Release.cs | 8 +- .../Models/ReleaseItem.cs | 20 +- .../Models/ReleaseModel.cs | 37 +- .../Models/RoleModel.cs | 55 +- Contentstack.Management.Core/Models/Stack.cs | 44 +- .../Models/StackSettings.cs | 8 +- .../Models/Taxonomy.cs | 16 +- .../Models/TaxonomyModel.cs | 27 +- Contentstack.Management.Core/Models/Term.cs | 24 +- .../Models/TermModel.cs | 49 +- .../Models/TextNode.cs | 3 - .../Models/Token/DeliveryToken.cs | 1 - .../Models/Token/DeliveryTokenModel.cs | 38 +- Contentstack.Management.Core/Models/User.cs | 8 +- .../Models/VariantGroup.cs | 8 +- .../Models/Version.cs | 12 +- .../Models/Webhook.cs | 12 +- .../Models/WebhookModel.cs | 30 +- .../Models/Workflow.cs | 16 +- .../Models/WorkflowModel.cs | 40 +- Contentstack.Management.Core/OAuthHandler.cs | 12 +- .../Queryable/ParameterCollection.cs | 10 +- .../Queryable/QueryParamValue.cs | 14 +- .../Services/ContentstackService.cs | 18 +- .../Services/DeleteReleaseItemService.cs | 17 +- .../Services/IContentstackService.cs | 1 - .../Models/CreateUpdateFolderService.cs | 26 +- .../Services/Models/CreateUpdateService.cs | 19 +- .../Services/Models/DeleteService.cs | 17 +- .../Services/Models/FetchDeleteService.cs | 6 +- .../Services/Models/FetchReferencesService.cs | 6 +- .../Models/GlobalFieldFetchDeleteService.cs | 6 +- .../Services/Models/GlobalFieldService.cs | 29 +- .../Services/Models/ImportExportService.cs | 6 +- .../Services/Models/LocaleService.cs | 6 +- .../Services/Models/LocalizationService.cs | 17 +- .../Models/PublishUnpublishService.cs | 63 +- .../Services/Models/UploadService.cs | 6 +- .../Models/VariantContentTypeLinkService.cs | 30 +- .../Models/Versioning/VersionService.cs | 33 +- .../OAuth/OAuthAppAuthorizationService.cs | 6 +- .../OAuth/OAuthAppRevocationService.cs | 6 +- .../Services/OAuth/OAuthTokenService.cs | 22 +- .../Services/Organization/GetOrganizations.cs | 6 +- .../Services/Organization/OrgRoles.cs | 4 +- .../Organization/OrganizationStackService.cs | 4 +- .../Organization/ResendInvitationService.cs | 4 +- .../Organization/TransferOwnershipService.cs | 18 +- .../Organization/UserInvitationService.cs | 96 +- .../Services/QueryService.cs | 3 +- .../BulkOperation/BulkAddItemsService.cs | 8 +- .../Stack/BulkOperation/BulkDeleteService.cs | 8 +- .../BulkOperation/BulkJobStatusService.cs | 6 +- .../Stack/BulkOperation/BulkPublishService.cs | 8 +- .../BulkOperation/BulkReleaseItemsService.cs | 8 +- .../BulkOperation/BulkUnpublishService.cs | 8 +- .../BulkOperation/BulkUpdateItemsService.cs | 8 +- .../BulkWorkflowUpdateService.cs | 8 +- .../Services/Stack/FetchStackService.cs | 6 +- .../Stack/StackCreateUpdateService.cs | 37 +- .../Services/Stack/StackOwnershipService.cs | 20 +- .../Services/Stack/StackSettingsService.cs | 6 +- .../Services/Stack/StackShareService.cs | 21 +- .../Services/Stack/UpdateUserRoleService.cs | 19 +- .../Services/User/ForgotPasswordService.cs | 21 +- .../Services/User/GetLoggedInUserService.cs | 4 +- .../Services/User/LoginService.cs | 42 +- .../Services/User/LogoutService.cs | 4 +- .../Services/User/ResetPasswordService.cs | 27 +- .../Utils/BulkDeleteDetailsJsonConverter.cs | 72 ++ .../Utils/FieldJsonConverter.cs | 56 +- .../Utils/JsonSerializerOptionsExtensions.cs | 28 + .../Utils/NodeJsonConverter.cs | 64 +- .../Utils/TextNodeJsonConverter.cs | 51 +- .../contentstack.management.core.csproj | 4 +- 250 files changed, 3593 insertions(+), 2952 deletions(-) create mode 100644 COMPREHENSIVE_MIGRATION_GUIDE.md create mode 100644 Contentstack.Management.Core.Tests/GlobalUsings.cs create mode 100644 Contentstack.Management.Core.Unit.Tests/GlobalUsings.cs create mode 100644 Contentstack.Management.Core.Unit.Tests/TestJsonSerializerOptions.cs create mode 100644 Contentstack.Management.Core/Utils/BulkDeleteDetailsJsonConverter.cs create mode 100644 Contentstack.Management.Core/Utils/JsonSerializerOptionsExtensions.cs diff --git a/COMPREHENSIVE_MIGRATION_GUIDE.md b/COMPREHENSIVE_MIGRATION_GUIDE.md new file mode 100644 index 0000000..a5c1cab --- /dev/null +++ b/COMPREHENSIVE_MIGRATION_GUIDE.md @@ -0,0 +1,942 @@ +# Contentstack Management .NET SDK: Comprehensive Migration Guide +## Newtonsoft.Json → System.Text.Json + +This document provides a complete migration strategy for the Contentstack Management .NET SDK when moving from **Newtonsoft.Json** to **System.Text.Json**. This represents a **breaking change** requiring a **new major version** of the SDK. + +**Audience:** SDK developers, customers using the Management SDK, and teams planning the migration across all modules. + +--- + +## Table of Contents + +1. [Migration Status Overview](#migration-status-overview) +2. [Why This Changes Your Code](#why-this-changes-your-code) +3. [Quick Reference Mapping](#quick-reference-mapping) +4. [Module-by-Module Migration](#module-by-module-migration) +5. [Customer Migration Patterns](#customer-migration-patterns) +6. [Asset Module Deep Dive](#asset-module-deep-dive) +7. [Testing Strategy](#testing-strategy) +8. [Implementation Timeline](#implementation-timeline) +9. [Risk Assessment & Mitigation](#risk-assessment--mitigation) +10. [Complete Migration Checklist](#complete-migration-checklist) +11. [Troubleshooting Common Issues](#troubleshooting-common-issues) + +--- + +## Migration Status Overview + +The SDK migration spans multiple modules with varying complexity levels. Below is the current status across all modules: + +| Module Name | Code Changes with Related Files | Test Cases Changes | Documentation Changes | Implementation Time | +|-------------|--------------------------------|-------------------|----------------------|-------------------| +| **Asset** COMPLETED | **Yes** - 3 JsonProperty attrs, response methods, 62+ test calls | **Yes** - 4,161 lines, 62+ OpenJObjectResponse calls | **Yes** - Migration patterns, examples | **0.5 day** | +| **Stack** PLANNED | **Yes** - StackSettings (3 attrs), Stack model, response handling | **Yes** - 1,191 lines, ~25+ response calls | **Yes** - Core client patterns | **0.5 day** | +| **Organisation** PLANNED | **Yes** - Organization model, user invitations, role management | **Yes** - 578 lines, ~15+ response calls | **Yes** - Auth & management flows | **0.5 day** | +| **Taxonomy** PLANNED | **Yes** - TaxonomyModel (11 attrs), TermModel (19 attrs), complex tree structures | **Yes** - 6,575 lines, ~45+ response calls | **Yes** - Hierarchical data patterns | **0.5 day** | +| **Terms** PLANNED | **Yes** - TermModel integration, taxonomy relationships | **Yes** - Included in Taxonomy tests | **Yes** - Term management examples | **0.5 day** | +| **Users** PLANNED | **Yes** - User model, authentication, profile management | **Yes** - Included in Login/Organization tests | **Yes** - User auth patterns | **0.5 day** | +| **Content Type** IN_PROGRESS | **Yes** - ContentModelling (13 attrs), Field models (40+ attrs), schema validation | **Yes** - 2,273 lines (1,326+947), ~35+ response calls | **Yes** - Schema migration guide | **0.5 day** | +| **Entries** IN_PROGRESS | **Yes** - Entry model, IEntry interface, complex field handling | **Yes** - 5,884 lines, ~50+ response calls | **Yes** - Content management patterns | **0.5 day** | +| **Locale** PLANNED | **Yes** - LocaleModel (3 attrs), localization services | **Yes** - Integrated in Entry/ContentType tests | **Yes** - Localization examples | **0.5 day** | +| **Webhook** PLANNED | **Yes** - WebhookModel (11 attrs), event handling | **Yes** - Integrated with other module tests | **Yes** - Event handling patterns | **0.5 day** | +| **Workflows** PLANNED | **Yes** - WorkflowModel (16 attrs), EntryWorkflowStage (16 attrs), state management | **Yes** - 3,722 lines, ~35+ response calls | **Yes** - Workflow state patterns | **0.5 day** | +| **Entry Variants** PLANNED | **Yes** - EntryVariant models, PublishVariant (2 attrs), complex relationships | **Yes** - 3,460 lines, ~30+ response calls | **Yes** - Variant management | **0.5 day** | +| **Delivery Tokens** PLANNED | **Yes** - DeliveryTokenModel (12 attrs), token management | **Yes** - 2,708 lines, ~25+ response calls | **Yes** - Token auth patterns | **0.5 day** | +| **Variant Group** PLANNED | **Yes** - VariantGroup models, group management | **Yes** - 3,122 lines, ~30+ response calls | **Yes** - Group management | **0.5 day** | +| **Bulk Operation** PLANNED | **Yes** - BulkOperationModels (56 attrs), complex async operations | **Yes** - 4,344 lines, ~40+ response calls | **Yes** - Async operation patterns | **0.5 day** | +| **Global Fields** PLANNED | **Yes** - GlobalField models, GlobalFieldRefs (4 attrs), nested references | **Yes** - 4,586 lines (934+3,652), ~40+ response calls | **Yes** - Global field patterns | **0.5 day** | +| **Release Management** PLANNED | **Yes** - ReleaseModel (13 attrs), release items, publishing workflows | **Yes** - 1,655 lines, ~20+ response calls | **Yes** - Release cycle patterns | **0.5 day** | +| **Roles & Permissions** PLANNED | **Yes** - RoleModel (24 attrs), permission management, AssetRules | **Yes** - 2,891 lines, ~25+ response calls | **Yes** - Permission patterns | **0.5 day** | +| **Environment** PLANNED | **Yes** - EnvironmentModel (7 attrs), environment management | **Yes** - 1,894 lines, ~20+ response calls | **Yes** - Environment setup | **0.5 day** | + +### Summary Statistics +- **Total Modules**: 19 modules +- **Total Integration Test Lines**: ~51,000+ lines +- **Total JsonProperty Attributes**: ~300+ across 49 files +- **Total OpenJObjectResponse Calls**: ~500+ method calls to update +- **Total Estimated Time**: 2-3 weeks for complete migration (9.5 working days) + +### Legend +- **COMPLETED**: Full migration implemented and tested +- **IN_PROGRESS**: Migration currently underway +- **PLANNED**: Scheduled for migration (priority order listed) + +### Migration Complexity Analysis + +**Based on SDK codebase analysis:** +- **49 files** contain JsonProperty attributes requiring updates +- **~51,000+ lines** of integration test code need migration +- **~500+ method calls** to OpenJObjectResponse() need updates +- **19 modules** total requiring systematic migration + +**Priority Implementation Order:** +1. **High Priority** (Customer Impact): Entries, Content Types, Assets (COMPLETED) +2. **Medium Priority** (Core Features): Stack, Bulk Operations, Taxonomy +3. **Lower Priority** (Advanced Features): Workflows, Variants, Webhooks + +**Note**: The Asset module (COMPLETED) serves as the reference implementation pattern for all other modules. + +--- + +## Why This Changes Your Code + +The SDK currently exposes Newtonsoft.Json types and settings throughout its public API: + +| Area | Current Newtonsoft Usage | Impact Level | +|------|--------------------------|--------------| +| **Client configuration** | `ContentstackClient.SerializerSettings` | **HIGH** - Property name changes | +| **Raw JSON handling** | `JObject`, `JToken`, query parameters | **HIGH** - Type changes throughout | +| **Public methods** | `ContentstackResponse.OpenJObjectResponse()`, `ParameterCollection.AddQuery(JObject)` | **CRITICAL** - Method signature changes | +| **Model attributes** | `[JsonProperty(propertyName: "...")]` on all model classes | **HIGH** - Hundreds of attributes | +| **Custom converters** | `JsonConverter` implementations for fields and nodes | **HIGH** - Complete rewrite required | +| **Exception handling** | `Newtonsoft.Json.JsonException` | **LOW** - Namespace change only | + +After migration, all Newtonsoft types become **System.Text.Json** equivalents with **no binary or source compatibility**. + +--- + +## Quick Reference Mapping + +| Newtonsoft.Json | System.Text.Json | Migration Notes | +|-----------------|------------------|-----------------| +| `JsonSerializerSettings` | `JsonSerializerOptions` | Property configuration changes | +| `JsonConvert.SerializeObject(obj, settings)` | `JsonSerializer.Serialize(obj, options)` | Method name change | +| `JsonConvert.DeserializeObject(json, settings)` | `JsonSerializer.Deserialize(json, options)` | Method name change | +| `JObject.Parse(json)` | `JsonNode.Parse(json)!.AsObject()` | Return type handling | +| `JArray.Parse(json)` | `JsonNode.Parse(json)!.AsArray()` | Return type handling | +| `token.ToObject(serializer)` | `JsonSerializer.Deserialize(token.GetRawText(), options)` | Deserialization pattern | +| `jObject["field"]?.Value()` | `jsonObject["field"]?.GetValue()` | Value extraction method | +| `[JsonProperty("field_uid")]` | `[JsonPropertyName("field_uid")]` | Attribute name change | +| `Newtonsoft.Json.JsonConverter` | `System.Text.Json.Serialization.JsonConverter` | Namespace + rewrite required | + +--- + +## Detailed Change Analysis by Module Type + +### High-Complexity Modules (0.5 day each) + +#### Entries Module (5,884 test lines) +- **Model Changes**: Entry class, IEntry interface, complex field handling +- **JsonProperty Attributes**: Field-specific serialization across multiple field types +- **Integration Tests**: 50+ OpenJObjectResponse calls, complex content operations +- **Special Considerations**: Content relationships, field validation, publishing workflows + +#### Content Types Module (2,273 test lines) +- **Model Changes**: ContentModelling (13 attrs), Field models (40+ attrs across field types) +- **JsonProperty Attributes**: Schema definition, field metadata, validation rules +- **Integration Tests**: 35+ OpenJObjectResponse calls, schema operations +- **Special Considerations**: Field schema validation, polymorphic field deserialization + +#### Taxonomy Module (6,575 test lines) +- **Model Changes**: TaxonomyModel (11 attrs), TermModel (19 attrs), hierarchical structures +- **JsonProperty Attributes**: Tree structure serialization, parent-child relationships +- **Integration Tests**: 45+ OpenJObjectResponse calls, complex tree operations +- **Special Considerations**: Hierarchical data integrity, term relationships + +### Medium-Complexity Modules (0.5 day each) + +#### Bulk Operations Module (4,344 test lines) +- **Model Changes**: BulkOperationModels (56 attrs), async operation tracking +- **JsonProperty Attributes**: Operation status, item lists, result tracking +- **Integration Tests**: 40+ OpenJObjectResponse calls, async validation +- **Special Considerations**: Async operation patterns, status polling, error handling + +#### Global Fields Module (4,586 test lines) +- **Model Changes**: GlobalField models, GlobalFieldRefs (4 attrs), nested references +- **JsonProperty Attributes**: Field references, nested field structures +- **Integration Tests**: 40+ OpenJObjectResponse calls, reference validation +- **Special Considerations**: Cross-content-type references, field inheritance + +### Standard-Complexity Modules (0.5 day each) + +#### Standard Pattern for Most Modules: +1. **Model Updates**: Replace `[JsonProperty(propertyName: "name")]` with `[JsonPropertyName("name")]` +2. **Test Updates**: Replace `OpenJObjectResponse()` with `OpenJsonObjectResponse()` +3. **Navigation Updates**: Replace `?.ToString()` with `?.GetValue()` +4. **Collection Updates**: Initialize with `= new()` syntax + +--- + +## Module-by-Module Migration + +### 1. Client Configuration Changes + +**All modules are affected by client-level configuration changes.** + +#### Before (Newtonsoft — current SDK) +```csharp +using Newtonsoft.Json; + +var client = new ContentstackClient(options); + +// Configure JSON handling +client.SerializerSettings.NullValueHandling = NullValueHandling.Ignore; +client.SerializerSettings.DateFormatHandling = DateFormatHandling.IsoDateFormat; +client.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc; + +// Register custom converters +client.SerializerSettings.Converters.Add(new MyNewtonsoftConverter()); +``` + +#### After (System.Text.Json — migrated SDK) +```csharp +using System.Text.Json; +using System.Text.Json.Serialization; + +var client = new ContentstackClient(options); + +// Configure JSON handling (new property name) +client.SerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull; +client.SerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase; // if needed +// Note: STJ uses ISO 8601 by default for dates + +// Register custom converters (must be rewritten for STJ) +client.SerializerOptions.Converters.Add(new MySystemTextJsonConverter()); +``` + +### 2. Response Processing Changes + +**Affects all modules that process API responses.** + +#### Before (Response Reading) +```csharp +using Newtonsoft.Json.Linq; + +ContentstackResponse response = await entry.CreateAsync(model); +JObject raw = response.OpenJObjectResponse(); +string uid = raw["entry"]?["uid"]?.Value(); +``` + +#### After (Response Reading) +```csharp +using System.Text.Json.Nodes; + +ContentstackResponse response = await entry.CreateAsync(model); +JsonObject raw = response.OpenJsonObjectResponse(); // Method name change +string? uid = raw["entry"]?["uid"]?.GetValue(); +``` + +### 3. Query Parameter Changes + +**Affects modules with query functionality (Entries, Assets, Content Types, etc.).** + +#### Before (Query Building) +```csharp +using Newtonsoft.Json.Linq; + +var query = stack.ContentType("product").Entry().Query(); +var filter = new JObject +{ + ["title"] = "Featured Product", + ["status"] = "published" +}; +query.Parameters.AddQuery(filter); +``` + +#### After (Query Building) +```csharp +using System.Text.Json.Nodes; + +var query = stack.ContentType("product").Entry().Query(); +var filter = new JsonObject +{ + ["title"] = "Featured Product", + ["status"] = "published" +}; +query.Parameters.AddQuery(filter); // Same method, different parameter type +``` + +--- + +## Customer Migration Patterns + +### Pattern 1: Basic CRUD Operations + +**Applies to: All modules (Assets, Entries, Content Types, etc.)** + +#### Before +```csharp +using Newtonsoft.Json.Linq; + +// Create operation +var createResponse = await stack.Asset().CreateAsync(assetModel); +var responseObj = createResponse.OpenJObjectResponse(); +var uid = responseObj["asset"]["uid"]?.ToString(); + +// Fetch operation +var fetchResponse = await stack.Asset(uid).FetchAsync(); +var assetData = fetchResponse.OpenJObjectResponse(); +var title = assetData["asset"]["title"]?.ToString(); +``` + +#### After +```csharp +using System.Text.Json.Nodes; + +// Create operation +var createResponse = await stack.Asset().CreateAsync(assetModel); +var responseObj = createResponse.OpenJsonObjectResponse(); +var uid = responseObj["asset"]?["uid"]?.GetValue(); + +// Fetch operation +var fetchResponse = await stack.Asset(uid).FetchAsync(); +var assetData = fetchResponse.OpenJsonObjectResponse(); +var title = assetData["asset"]?["title"]?.GetValue(); +``` + +### Pattern 2: Complex Query Operations + +**Applies to: Entries, Assets, Content Types with filtering** + +#### Before +```csharp +using Newtonsoft.Json.Linq; + +var query = stack.ContentType("blog").Entry().Query(); +var complexFilter = new JObject +{ + ["title"] = new JObject + { + ["$regex"] = "^Featured" + }, + ["tags"] = new JObject + { + ["$in"] = new JArray { "news", "updates" } + } +}; +query.Parameters.AddQuery(complexFilter); + +var response = await query.FindAsync(); +var entries = response.OpenJObjectResponse()["entries"]?.ToArray(); +``` + +#### After +```csharp +using System.Text.Json.Nodes; + +var query = stack.ContentType("blog").Entry().Query(); +var complexFilter = new JsonObject +{ + ["title"] = new JsonObject + { + ["$regex"] = "^Featured" + }, + ["tags"] = new JsonObject + { + ["$in"] = new JsonArray { "news", "updates" } + } +}; +query.Parameters.AddQuery(complexFilter); + +var response = await query.FindAsync(); +var entries = response.OpenJsonObjectResponse()["entries"]?.AsArray(); +``` + +### Pattern 3: Bulk Operations + +**Applies to: Bulk Asset, Entry, and Publishing operations** + +#### Before +```csharp +using Newtonsoft.Json.Linq; + +var bulkItems = new List(); +foreach (var response in createResponses) +{ + var data = response.OpenJObjectResponse(); + bulkItems.Add(new BulkPublishAsset + { + Uid = data["asset"]["uid"]?.ToString() // Uses [JsonProperty] + }); +} +``` + +#### After +```csharp +using System.Text.Json.Nodes; + +var bulkItems = new List(); +foreach (var response in createResponses) +{ + var data = response.OpenJsonObjectResponse(); + bulkItems.Add(new BulkPublishAsset + { + Uid = data["asset"]?["uid"]?.GetValue() ?? "" // Uses [JsonPropertyName] + }); +} +``` + +--- + +## Asset Module Deep Dive + +*The Asset module serves as the reference implementation for all other modules.* + +### Complete File Inventory + +**Files Requiring Changes:** + +| File Path | Changes Required | Impact Level | +|-----------|------------------|--------------| +| `BulkOperationModels.cs` | 3 JsonProperty attributes → JsonPropertyName | **HIGH** | +| `RoleModel.cs` | 2 JsonProperty attributes → JsonPropertyName | **HIGH** | +| `ContentstackResponse.cs` | Method signature + constructor changes | **CRITICAL** | +| `IResponse.cs` | Interface method signature | **HIGH** | +| `ContentstackClient.cs` | Property type change | **HIGH** | +| `Contentstack013_AssetTest.cs` | 62+ OpenJObjectResponse calls | **CRITICAL** | +| `AssetTest.cs` | Mock configuration updates | **MEDIUM** | +| `MockResponse.cs` | Constructor parameter changes | **MEDIUM** | + +### Key Code Changes + +#### 1. BulkOperationModels.cs Changes + +**Before:** +```csharp +using Newtonsoft.Json; + +public class BulkPublishAsset +{ + [JsonProperty(propertyName: "uid")] + public string Uid { get; set; } +} +``` + +**After:** +```csharp +using System.Text.Json.Serialization; + +public class BulkPublishAsset +{ + [JsonPropertyName("uid")] + public string Uid { get; set; } = ""; +} +``` + +#### 2. Response Method Changes + +**Before:** +```csharp +using Newtonsoft.Json.Linq; + +public JObject OpenJObjectResponse() +{ + ThrowIfDisposed(); + return JObject.Parse(OpenResponse()); +} +``` + +**After:** +```csharp +using System.Text.Json.Nodes; + +public JsonObject OpenJsonObjectResponse() +{ + ThrowIfDisposed(); + return JsonNode.Parse(OpenResponse())!.AsObject(); +} +``` + +#### 3. Integration Test Updates + +**Before:** +```csharp +var responseObject = response.OpenJObjectResponse(); +var assetUid = responseObject["asset"]["uid"]?.ToString(); +var filename = responseObject["asset"]["filename"]?.ToString(); +``` + +**After:** +```csharp +var responseObject = response.OpenJsonObjectResponse(); +var assetUid = responseObject["asset"]?["uid"]?.GetValue(); +var filename = responseObject["asset"]?["filename"]?.GetValue(); +``` + +### Asset Migration Time Estimates + +| Component | Time Estimate | Complexity | +|-----------|---------------|------------| +| Model attribute changes | 30 minutes | Low | +| Response method changes | 1 hour | Medium | +| Integration test updates | 8-12 hours | High | +| Unit test infrastructure | 2-3 hours | Medium | +| Testing & validation | 4-6 hours | Medium | + +**Total Asset Module: 4-6 hours (0.5 day)** + +--- + +## Testing Strategy + +### 1. Unit Test Migration + +**Pattern for all modules:** + +#### Before (Newtonsoft) +```csharp +using Newtonsoft.Json; + +[TestMethod] +public void Should_Serialize_Model_Correctly() +{ + var settings = new JsonSerializerSettings(); + settings.Converters.Add(new CustomConverter()); + + var json = JsonConvert.SerializeObject(model, settings); + var result = JsonConvert.DeserializeObject(json, settings); + + Assert.AreEqual(expected, result.Property); +} +``` + +#### After (System.Text.Json) +```csharp +using System.Text.Json; + +[TestMethod] +public void Should_Serialize_Model_Correctly() +{ + var options = new JsonSerializerOptions(); + options.Converters.Add(new CustomConverter()); + + var json = JsonSerializer.Serialize(model, options); + var result = JsonSerializer.Deserialize(json, options); + + Assert.AreEqual(expected, result.Property); +} +``` + +### 2. Integration Test Migration + +**Pattern for all modules with API responses:** + +#### Before +```csharp +[TestMethod] +public async Task Should_Create_Resource_Successfully() +{ + var response = await client.Stack(apiKey, token) + .Resource() + .CreateAsync(model); + + var responseObject = response.OpenJObjectResponse(); + var resourceUid = responseObject["resource"]["uid"]?.Value(); + + Assert.IsNotNull(resourceUid); +} +``` + +#### After +```csharp +[TestMethod] +public async Task Should_Create_Resource_Successfully() +{ + var response = await client.Stack(apiKey, token) + .Resource() + .CreateAsync(model); + + var responseObject = response.OpenJsonObjectResponse(); + var resourceUid = responseObject["resource"]?["uid"]?.GetValue(); + + Assert.IsNotNull(resourceUid); +} +``` + +### 3. Mock Infrastructure Updates + +**Required for all test projects:** + +#### Before +```csharp +public static ContentstackResponse CreateMockResponse(string fileName) +{ + var httpResponse = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(File.ReadAllText($"MockData/{fileName}")) + }; + + var serializer = JsonSerializer.Create(new JsonSerializerSettings()); + return new ContentstackResponse(httpResponse, serializer); +} +``` + +#### After +```csharp +public static ContentstackResponse CreateMockResponse(string fileName) +{ + var httpResponse = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(File.ReadAllText($"MockData/{fileName}")) + }; + + var options = new JsonSerializerOptions(); + return new ContentstackResponse(httpResponse, options); +} +``` + +--- + +## Implementation Timeline + +### Phase 1: Core Infrastructure (Week 1) +- [ ] **ContentstackClient.SerializerSettings → SerializerOptions** +- [ ] **ContentstackResponse method signature changes** +- [ ] **IResponse interface updates** +- [ ] **Base test infrastructure updates** + +### Phase 2: Model Attributes (Week 2) +- [ ] **Scan all model files for [JsonProperty] attributes** +- [ ] **Replace with [JsonPropertyName] systematically** +- [ ] **Update collection initializers to use new() syntax** + +### Phase 3: Module Implementation (Week 3) + +**Optimized Priority Order with Reduced Effort Estimates:** + +#### Week 3: All Modules (5 working days) +**Day 1:** +1. **Asset Module** COMPLETED (0.5 day - completed reference implementation) +2. **Entry Module** IN_PROGRESS (0.5 day - 5,884 test lines, 50+ response calls) + +**Day 2:** +3. **Content Type Module** IN_PROGRESS (0.5 day - 2,273 test lines, 40+ field attributes) +4. **Stack Module** (0.5 day - 1,191 test lines, core client patterns) + +**Day 3:** +5. **Global Fields Module** (0.5 day - 4,586 test lines, nested references) +6. **Taxonomy Module** (0.5 day - 6,575 test lines, hierarchical data) + +**Day 4:** +7. **Bulk Operations** (0.5 day - 4,344 test lines, 56 attributes, async operations) +8. **Workflows** (0.5 day - 3,722 test lines, 32+ attributes across models) + +**Day 5:** +9. **Entry Variants** (0.5 day - 3,460 test lines, variant relationships) +10. **Variant Groups** (0.5 day - 3,122 test lines, group management) + +#### Additional 4.5 Days (Remaining 9 Modules) +**Days 6-10:** +11. **Roles & Permissions** (0.5 day - 2,891 test lines, 24+ attributes) +12. **Delivery Tokens** (0.5 day - 2,708 test lines, 12 attributes) +13. **Environment** (0.5 day - 1,894 test lines, 7 attributes) +14. **Release Management** (0.5 day - 1,655 test lines, release workflows) +15. **Organisation** (0.5 day - 578 test lines, user management) +16. **Webhook** (0.5 day - event handling patterns) +17. **Users/Auth** (0.5 day - authentication flows) +18. **Locale** (0.5 day - localization services) +19. **Terms** (0.5 day - taxonomy integration) + +### Phase 4: Integration Testing (Week 4 - Days 1-2) +- [ ] **Module-by-module integration test validation** +- [ ] **Cross-module integration verification** +- [ ] **Performance regression testing** + +### Phase 5: Documentation & Release (Week 4 - Days 3-5) +- [ ] **Update all code examples in documentation** +- [ ] **Finalize migration guides for each module** +- [ ] **Prepare release notes and breaking change documentation** + +--- + +## Risk Assessment & Mitigation + +### Critical Risks + +| Risk | Impact | Probability | Mitigation Strategy | +|------|---------|-------------|-------------------| +| **Mass integration test failures** | **Critical** | **High** | 51k+ lines need updates; systematic pattern-based approach | +| **Customer code breaks completely** | **Critical** | **High** | 500+ method calls break; comprehensive migration guide | +| **Field serialization errors** | **Critical** | **Medium** | 300+ JsonProperty attrs; automated validation scripts | +| **Performance regressions** | **High** | **Medium** | Benchmark critical paths; STJ performance monitoring | +| **Complex converter migration** | **High** | **High** | Field polymorphism critical; reference implementations | +| **Timeline overrun** | **Medium** | **Medium** | 8-9 week estimate; module-by-module validation | + +### Module-Specific Risks + +| Module | Primary Risk | Mitigation | +|--------|-------------|------------| +| **Entries** | Complex field relationships break | Comprehensive field testing, type validation | +| **Content Types** | Schema validation failures | Field polymorphism testing, converter validation | +| **Taxonomy** | Hierarchical data integrity | Tree structure validation, relationship testing | +| **Bulk Operations** | Async operation tracking fails | Status polling tests, error handling validation | +| **Global Fields** | Cross-reference resolution breaks | Reference integrity tests, dependency validation | + +### High-Risk Areas + +#### 1. Polymorphic Field Deserialization +**Problem**: `FieldJsonConverter` complexity for content type schemas +**Solution**: Careful STJ converter rewrite with extensive validation + +#### 2. Scale of Model Attributes +**Problem**: Hundreds of `[JsonProperty]` attributes across 39+ model files +**Solution**: Automated scanning and replacement with validation scripts + +#### 3. No SelectToken Equivalent +**Problem**: Complex JSON path operations break +**Solution**: Convert to typed model deserialization or manual navigation + +#### 4. Binary Incompatibility +**Problem**: Complete breaking change for all customers +**Solution**: Major version bump with comprehensive migration support + +### Mitigation Strategies + +1. **Automated Testing**: Run full integration test suite after each module migration +2. **Beta Release Program**: Early access for key customers to validate migration +3. **Migration Tooling**: Scripts to help identify customer code that needs updates +4. **Support Documentation**: Detailed FAQ and troubleshooting guide +5. **Rollback Plan**: Maintain parallel Newtonsoft version during transition period + +--- + +## Complete Migration Checklist + +### For SDK Development Team + +#### Infrastructure Changes +- [ ] Update `ContentstackClient.SerializerSettings` → `SerializerOptions` +- [ ] Update `ContentstackResponse.OpenJObjectResponse()` → `OpenJsonObjectResponse()` +- [ ] Update `IResponse` interface method signatures +- [ ] Update constructor parameters throughout pipeline +- [ ] Update exception handling for `System.Text.Json.JsonException` + +#### Model Changes (Per Module) +- [ ] Replace all `[JsonProperty(propertyName: "name")]` → `[JsonPropertyName("name")]` +- [ ] Update collection initializers with `= new()` syntax +- [ ] Update custom converter implementations +- [ ] Validate serialization output matches API requirements + +#### Test Infrastructure +- [ ] Update mock response creation with `JsonSerializerOptions` +- [ ] Update test client configuration +- [ ] Update assertion patterns for JSON navigation +- [ ] Validate all unit tests pass + +#### Integration Tests (Per Module) +- [ ] Update all `OpenJObjectResponse()` calls +- [ ] Update JSON field access from `.ToString()` → `.GetValue()` +- [ ] Update array iteration patterns +- [ ] Update complex object deserialization +- [ ] Ensure null-conditional operators throughout + +#### Documentation +- [ ] Update all code examples in API documentation +- [ ] Create module-specific migration guides +- [ ] Update README with migration information +- [ ] Add troubleshooting section + +### For Customer Migration + +#### Code Analysis +- [ ] Search codebase for `JObject`, `JToken`, `JArray` +- [ ] Find all `JsonConvert` usage +- [ ] Locate `JsonSerializerSettings` configurations +- [ ] Identify `[JsonProperty]` attributes in custom models +- [ ] Find custom Newtonsoft `JsonConverter` implementations + +#### Client Configuration Updates +- [ ] Replace `SerializerSettings` with `SerializerOptions` +- [ ] Update null handling configuration +- [ ] Update date handling configuration +- [ ] Migrate custom converter registrations + +#### Response Processing Updates +- [ ] Change `OpenJObjectResponse()` → `OpenJsonObjectResponse()` +- [ ] Update JSON navigation patterns +- [ ] Update type extraction methods +- [ ] Add null-conditional operators + +#### Query Building Updates +- [ ] Replace `JObject` → `JsonObject` in query parameters +- [ ] Replace `JArray` → `JsonArray` in filter construction +- [ ] Update complex query object building + +#### Testing Updates +- [ ] Update integration tests with new response patterns +- [ ] Update mock setups with new serializer configuration +- [ ] Update assertion patterns +- [ ] Run full test suite validation + +#### Exception Handling +- [ ] Update catch blocks for `System.Text.Json.JsonException` +- [ ] Update error message parsing if applicable + +--- + +## Troubleshooting Common Issues + +### Issue 1: "Method not found: OpenJObjectResponse" + +**Symptoms**: Compilation error when calling response methods +**Cause**: Method renamed in migration +**Solution**: Replace with `OpenJsonObjectResponse()` + +```csharp +// Before (breaks) +var data = response.OpenJObjectResponse(); + +// After (works) +var data = response.OpenJsonObjectResponse(); +``` + +### Issue 2: "Cannot convert JObject to JsonObject" + +**Symptoms**: Type mismatch errors in query building +**Cause**: Parameter type changes in AddQuery methods +**Solution**: Use JsonObject instead of JObject + +```csharp +// Before (breaks) +var filter = new JObject { ["key"] = "value" }; + +// After (works) +var filter = new JsonObject { ["key"] = "value" }; +``` + +### Issue 3: "Value() method not found" + +**Symptoms**: JSON navigation compilation errors +**Cause**: Different value extraction API in System.Text.Json +**Solution**: Use GetValue() method + +```csharp +// Before (breaks) +var uid = jsonObj["uid"]?.Value(); + +// After (works) +var uid = jsonObj["uid"]?.GetValue(); +``` + +### Issue 4: "JsonProperty attribute not recognized" + +**Symptoms**: Serialization using wrong property names +**Cause**: Attribute name change +**Solution**: Replace with JsonPropertyName + +```csharp +// Before (breaks) +[JsonProperty(propertyName: "content_type")] + +// After (works) +[JsonPropertyName("content_type")] +``` + +### Issue 5: Custom converter errors + +**Symptoms**: Converter registration or execution failures +**Cause**: Different converter base class and methods +**Solution**: Rewrite converters for System.Text.Json + +```csharp +// Before (Newtonsoft) +public class MyConverter : JsonConverter +{ + public override MyType ReadJson(JsonReader reader, ...) { } + public override void WriteJson(JsonWriter writer, ...) { } +} + +// After (System.Text.Json) +public class MyConverter : JsonConverter +{ + public override MyType Read(ref Utf8JsonReader reader, ...) { } + public override void Write(Utf8JsonWriter writer, ...) { } +} +``` + +### Issue 6: Performance differences + +**Symptoms**: Slower response processing or memory usage changes +**Cause**: Different performance characteristics between libraries +**Solution**: Profile and optimize critical paths + +- Use JsonSerializerOptions caching +- Consider source generators for high-performance scenarios +- Monitor memory allocation patterns + +### Issue 7: Null handling differences + +**Symptoms**: Unexpected null values or deserialization failures +**Cause**: Stricter null handling in System.Text.Json +**Solution**: Add proper null checking and configuration + +```csharp +// Configure null handling +client.SerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull; + +// Use null-conditional operators +var value = jsonObj["field"]?.GetValue(); +``` + +--- + +## Support Resources + +### Migration Tools +- **Code Scanner**: Script to identify Newtonsoft usage patterns +- **Attribute Replacer**: Tool to update JsonProperty attributes +- **Test Validator**: Automated integration test verification + +### Documentation Links +- [System.Text.Json Overview](https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-overview) +- [Migrate from Newtonsoft.Json](https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/migrate-from-newtonsoft-how-to) +- [JsonConverter Migration Guide](https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/converters-how-to) + +### Team Contacts +- **SDK Team**: For core migration questions and technical issues +- **Developer Relations**: For customer migration support and feedback +- **Documentation Team**: For migration guide updates and improvements + +--- + +## Migration Summary & Statistics + +### Overall Scope +- **Total Modules**: 19 modules requiring migration +- **Completed Modules**: 1 (Asset COMPLETED) +- **Remaining Modules**: 18 modules +- **Estimated Timeline**: 2-3 weeks total effort + +### Code Change Statistics +- **Integration Test Files**: 18 files totaling 51,000+ lines +- **JsonProperty Attributes**: ~300+ attributes across 49+ files +- **Method Call Updates**: ~500+ OpenJObjectResponse() calls +- **Model Files**: 100+ model files requiring updates + +### Effort Distribution +- **High Complexity** (3 modules): 1.5 days total (0.5 day each) + - Entries, Content Types, Taxonomy +- **Medium Complexity** (8 modules): 4 days total (0.5 day each) + - Bulk Operations, Global Fields, Workflows, Variants, etc. +- **Standard Complexity** (8 modules): 4 days total (0.5 day each) + - Stack, Organization, Webhooks, Environment, etc. + +### Customer Impact Assessment +- **Breaking Changes**: 100% of SDK-facing code breaks +- **Migration Required**: All customers must update before upgrading +- **Support Period**: 6 months parallel support recommended +- **Beta Testing**: 2-month beta period for major customers + +### Success Criteria +- [ ] All 51k+ integration test lines pass +- [ ] All 300+ JsonProperty attributes converted +- [ ] All 500+ method calls updated +- [ ] Zero API behavior changes +- [ ] Performance parity maintained +- [ ] Customer migration guide validated + +--- + +## Document History + +| Version | Date | Changes | Author | +|---------|------|---------|--------| +| 1.0 | 2026-05-07 | Initial comprehensive migration guide with detailed module analysis | SDK Team | +| 1.1 | 2026-05-07 | Updated timeline to 2-3 days per module, removed emojis, revised to 8-9 week total | SDK Team | +| 1.2 | 2026-05-11 | Optimized timeline to 0.5 day per module, compressed total to 2-3 weeks | SDK Team | + +--- + +This comprehensive migration guide provides detailed analysis of all 19 modules in the SDK migration. It will be updated as each module completes its migration, providing customers with module-specific guidance and the development team with implementation patterns and validation criteria. + +**Next Update**: After Content Types and Entries modules complete migration (Week 3, Day 2) \ No newline at end of file diff --git a/Contentstack.Management.Core.Tests/Contentstack.Management.Core.Tests.csproj b/Contentstack.Management.Core.Tests/Contentstack.Management.Core.Tests.csproj index a8efdf8..72cd67e 100644 --- a/Contentstack.Management.Core.Tests/Contentstack.Management.Core.Tests.csproj +++ b/Contentstack.Management.Core.Tests/Contentstack.Management.Core.Tests.csproj @@ -1,7 +1,7 @@ - net7.0 + net10.0 false $(Version) @@ -24,7 +24,6 @@ - diff --git a/Contentstack.Management.Core.Tests/Contentstack.cs b/Contentstack.Management.Core.Tests/Contentstack.cs index 39129a4..d56382b 100644 --- a/Contentstack.Management.Core.Tests/Contentstack.cs +++ b/Contentstack.Management.Core.Tests/Contentstack.cs @@ -5,14 +5,13 @@ using System.Net; using System.Net.Http; using System.Reflection; +using System.Text.Json; using System.Threading.Tasks; using Contentstack.Management.Core.Exceptions; using Contentstack.Management.Core.Tests.Helpers; using Contentstack.Management.Core.Tests.Model; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Options; -using Newtonsoft.Json; -using Newtonsoft.Json.Linq; namespace Contentstack.Management.Core.Tests { @@ -119,17 +118,13 @@ public static ContentstackResponse LoginWithRetry(ContentstackClient client, int } catch (Exception ex) when (IsAccountLockout(ex) && attempt < maxRetries) { - int delay = baseDelayMs * (int)Math.Pow(2, attempt); // Exponential backoff + int delay = baseDelayMs * (int)Math.Pow(2, attempt); System.Threading.Thread.Sleep(delay); } } - // Final attempt without catching lockout return client.Login(Credential, null, MfaSecret); } - /// - /// Executes async login with retry logic for account lockouts - /// public static async Task LoginWithRetryAsync(ContentstackClient client, int maxRetries = 3, int baseDelayMs = 5000) { for (int attempt = 0; attempt <= maxRetries; attempt++) @@ -140,88 +135,61 @@ public static async Task LoginWithRetryAsync(ContentstackC } catch (Exception ex) when (IsAccountLockout(ex) && attempt < maxRetries) { - int delay = baseDelayMs * (int)Math.Pow(2, attempt); // Exponential backoff + int delay = baseDelayMs * (int)Math.Pow(2, attempt); await Task.Delay(delay); } } - // Final attempt without catching lockout return await client.LoginAsync(Credential, null, MfaSecret); } - /// - /// Executes login with TOTP-aware retry logic for token reuse and account lockouts - /// public static ContentstackResponse LoginWithTotpRetry(ContentstackClient client, int maxRetries = 3) { for (int attempt = 0; attempt <= maxRetries; attempt++) { try { - // Ensure fresh TOTP window before each attempt EnsureFreshTotpWindow(); return client.Login(Credential, null, MfaSecret); } catch (Exception ex) when (attempt < maxRetries) { if (IsTotpReuse(ex)) - { - // Wait for fresh TOTP window (35+ seconds) System.Threading.Thread.Sleep(35000); - } else if (IsAccountLockout(ex)) { - // Exponential backoff for account lockout int delay = 5000 * (int)Math.Pow(2, attempt); System.Threading.Thread.Sleep(delay); } else - { - // For other errors, short delay before retry System.Threading.Thread.Sleep(1000); - } } } - - // Final attempt without catching errors EnsureFreshTotpWindow(); return client.Login(Credential, null, MfaSecret); } - /// - /// Executes async login with TOTP-aware retry logic for token reuse and account lockouts - /// public static async Task LoginWithTotpRetryAsync(ContentstackClient client, int maxRetries = 3) { for (int attempt = 0; attempt <= maxRetries; attempt++) { try { - // Ensure fresh TOTP window before each attempt EnsureFreshTotpWindow(); return await client.LoginAsync(Credential, null, MfaSecret); } catch (Exception ex) when (attempt < maxRetries) { if (IsTotpReuse(ex)) - { - // Wait for fresh TOTP window (35+ seconds) await Task.Delay(35000); - } else if (IsAccountLockout(ex)) { - // Exponential backoff for account lockout int delay = 5000 * (int)Math.Pow(2, attempt); await Task.Delay(delay); } else - { - // For other errors, short delay before retry await Task.Delay(1000); - } } } - - // Final attempt without catching errors EnsureFreshTotpWindow(); return await client.LoginAsync(Credential, null, MfaSecret); } @@ -242,17 +210,16 @@ public static ContentstackClient CreateAuthenticatedClient() return client; } - public static T serialize(JsonSerializer serializer, string filePath) + public static T serialize(JsonSerializerOptions options, string filePath) { string response = GetResourceText(filePath); - JObject jObject = JObject.Parse(response); - return jObject.ToObject(serializer); + return JsonSerializer.Deserialize(response, options); } - public static T serializeArray(JsonSerializer serializer, string filePath) + + public static T serializeArray(JsonSerializerOptions options, string filePath) { string response = GetResourceText(filePath); - JArray jObject = JArray.Parse(response); - return jObject.ToObject(serializer); + return JsonSerializer.Deserialize(response, options); } public static string GetResourceText(string resourceName) diff --git a/Contentstack.Management.Core.Tests/GlobalUsings.cs b/Contentstack.Management.Core.Tests/GlobalUsings.cs new file mode 100644 index 0000000..ae3bf25 --- /dev/null +++ b/Contentstack.Management.Core.Tests/GlobalUsings.cs @@ -0,0 +1,4 @@ +global using System.Text.Json; +global using System.Text.Json.Nodes; +global using System.Text.Json.Serialization; +global using JsonException = System.Text.Json.JsonException; diff --git a/Contentstack.Management.Core.Tests/Helpers/ContentTypeFixtureLoader.cs b/Contentstack.Management.Core.Tests/Helpers/ContentTypeFixtureLoader.cs index 9c62fab..ecb0081 100644 --- a/Contentstack.Management.Core.Tests/Helpers/ContentTypeFixtureLoader.cs +++ b/Contentstack.Management.Core.Tests/Helpers/ContentTypeFixtureLoader.cs @@ -1,6 +1,6 @@ +using System.Text.Json; +using System.Text.Json.Nodes; using Contentstack.Management.Core.Models; -using Newtonsoft.Json; -using Newtonsoft.Json.Linq; namespace Contentstack.Management.Core.Tests.Helpers { @@ -9,15 +9,15 @@ namespace Contentstack.Management.Core.Tests.Helpers /// public static class ContentTypeFixtureLoader { - public static ContentModelling LoadFromMock(JsonSerializer serializer, string embeddedFileName, string uidSuffix) + public static ContentModelling LoadFromMock(JsonSerializerOptions options, string embeddedFileName, string uidSuffix) { var text = Contentstack.GetResourceText(embeddedFileName); - var jo = JObject.Parse(text); - var baseUid = jo["uid"]?.Value() ?? "ct"; - jo["uid"] = $"{baseUid}_{uidSuffix}"; - var title = jo["title"]?.Value() ?? "CT"; - jo["title"] = $"{title} {uidSuffix}"; - return jo.ToObject(serializer); + var root = JsonNode.Parse(text)!.AsObject(); + var baseUid = root["uid"]?.GetValue() ?? "ct"; + root["uid"] = $"{baseUid}_{uidSuffix}"; + var title = root["title"]?.GetValue() ?? "CT"; + root["title"] = $"{title} {uidSuffix}"; + return root.Deserialize(options); } } } diff --git a/Contentstack.Management.Core.Tests/Helpers/MockHttpStatusHandler.cs b/Contentstack.Management.Core.Tests/Helpers/MockHttpStatusHandler.cs index d339d6e..e0e5eb2 100644 --- a/Contentstack.Management.Core.Tests/Helpers/MockHttpStatusHandler.cs +++ b/Contentstack.Management.Core.Tests/Helpers/MockHttpStatusHandler.cs @@ -5,7 +5,7 @@ using System.Text; using System.Threading; using System.Threading.Tasks; -using Newtonsoft.Json; +using System.Text.Json; namespace Contentstack.Management.Core.Tests.Helpers { @@ -44,7 +44,7 @@ protected override async Task SendAsync( errors = _additionalFields }; - var jsonContent = JsonConvert.SerializeObject(errorResponse); + var jsonContent = JsonSerializer.Serialize(errorResponse); var response = new HttpResponseMessage(_statusCode) { Content = new StringContent(jsonContent, Encoding.UTF8, "application/json"), diff --git a/Contentstack.Management.Core.Tests/Helpers/TestOutputLogger.cs b/Contentstack.Management.Core.Tests/Helpers/TestOutputLogger.cs index 557588a..e9e614e 100644 --- a/Contentstack.Management.Core.Tests/Helpers/TestOutputLogger.cs +++ b/Contentstack.Management.Core.Tests/Helpers/TestOutputLogger.cs @@ -1,6 +1,6 @@ using System; using System.Collections.Generic; -using Newtonsoft.Json; +using System.Text.Json; namespace Contentstack.Management.Core.Tests.Helpers { @@ -64,7 +64,7 @@ private static void Emit(object data) { try { - var json = JsonConvert.SerializeObject(data, Formatting.None); + var json = JsonSerializer.Serialize(data); Console.Write(START_MARKER); Console.Write(json); Console.WriteLine(END_MARKER); diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack001_LoginTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack001_LoginTest.cs index 01f61c4..f94bfcc 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack001_LoginTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack001_LoginTest.cs @@ -8,7 +8,6 @@ using Contentstack.Management.Core.Tests.Helpers; using Microsoft.VisualStudio.TestTools.UnitTesting; using Contentstack.Management.Core.Queryable; -using Newtonsoft.Json.Linq; namespace Contentstack.Management.Core.Tests.IntegrationTest { @@ -145,7 +144,7 @@ public void Test005_Should_Return_Loggedin_User() ContentstackResponse response = client.GetUser(); - var user = response.OpenJObjectResponse(); + var user = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(user, "user"); @@ -169,11 +168,11 @@ public async System.Threading.Tasks.Task Test006_Should_Return_Loggedin_User_Asy ContentstackResponse response = await client.GetUserAsync(); - var user = response.OpenJObjectResponse(); + var user = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(user, "user"); AssertLogger.IsNotNull(user["user"]["organizations"], "organizations"); - AssertLogger.IsInstanceOfType(user["user"]["organizations"], typeof(JArray), "organizations"); + AssertLogger.IsInstanceOfType(user["user"]["organizations"], typeof(JsonArray), "organizations"); AssertLogger.IsNull(user["user"]["organizations"][0]["org_roles"], "org_roles"); } @@ -199,11 +198,11 @@ public void Test007_Should_Return_Loggedin_User_With_Organizations_detail() ContentstackResponse response = client.GetUser(collection); - var user = response.OpenJObjectResponse(); + var user = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(user, "user"); AssertLogger.IsNotNull(user["user"]["organizations"], "organizations"); - AssertLogger.IsInstanceOfType(user["user"]["organizations"], typeof(JArray), "organizations"); + AssertLogger.IsInstanceOfType(user["user"]["organizations"], typeof(JsonArray), "organizations"); AssertLogger.IsNotNull(user["user"]["organizations"][0]["org_roles"], "org_roles"); } catch (Exception e) @@ -1000,7 +999,7 @@ public void Test056_Should_Handle_Malformed_JSON_Response_Sync() { AssertLogger.IsTrue(true, "ContentstackErrorException acceptable for malformed JSON"); } - catch (Newtonsoft.Json.JsonException) + catch (JsonException) { AssertLogger.IsTrue(true, "JsonException acceptable for malformed JSON"); } @@ -1027,7 +1026,7 @@ public async System.Threading.Tasks.Task Test057_Should_Handle_Malformed_JSON_Re { AssertLogger.IsTrue(true, "ContentstackErrorException acceptable for malformed JSON"); } - catch (Newtonsoft.Json.JsonException) + catch (JsonException) { AssertLogger.IsTrue(true, "JsonException acceptable for malformed JSON"); } @@ -1058,7 +1057,7 @@ public void Test058_Should_Handle_Empty_Response_Body_Sync() { AssertLogger.IsTrue(true, "ArgumentException acceptable for empty response"); } - catch (Newtonsoft.Json.JsonReaderException) + catch (JsonException) { AssertLogger.IsTrue(true, "JsonReaderException acceptable for empty response"); } @@ -1089,7 +1088,7 @@ public async System.Threading.Tasks.Task Test059_Should_Handle_Empty_Response_Bo { AssertLogger.IsTrue(true, "ArgumentException acceptable for empty response"); } - catch (Newtonsoft.Json.JsonReaderException) + catch (JsonException) { AssertLogger.IsTrue(true, "JsonReaderException acceptable for empty response"); } @@ -1141,7 +1140,7 @@ public void Test060_Should_Handle_Unexpected_Response_Structure_Sync() { AssertLogger.IsTrue(true, "KeyNotFoundException acceptable for unexpected structure"); } - catch (Newtonsoft.Json.JsonException) + catch (JsonException) { AssertLogger.IsTrue(true, "JsonException acceptable for unexpected structure"); } @@ -1393,7 +1392,7 @@ public void Test073_Should_Handle_GetUser_Malformed_Response_Sync() { AssertLogger.IsTrue(true, "ContentstackErrorException acceptable for malformed response"); } - catch (Newtonsoft.Json.JsonException) + catch (JsonException) { AssertLogger.IsTrue(true, "JsonException acceptable for malformed response"); } @@ -1856,7 +1855,7 @@ public async System.Threading.Tasks.Task Test100_Should_Validate_Complete_Error_ { results.Add((scenario, false, "TaskCanceledException")); } - catch (Newtonsoft.Json.JsonException) + catch (JsonException) { results.Add((scenario, false, "JsonException")); } diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack002_OrganisationTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack002_OrganisationTest.cs index 12cd9c4..928fca6 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack002_OrganisationTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack002_OrganisationTest.cs @@ -8,8 +8,6 @@ using Contentstack.Management.Core.Tests.Helpers; using Contentstack.Management.Core.Tests.Model; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json.Linq; - namespace Contentstack.Management.Core.Tests.IntegrationTest { [TestClass] @@ -48,9 +46,9 @@ public void Test001_Should_Return_All_Organizations() ContentstackResponse contentstackResponse = organization.GetOrganizations(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); - _count = (response["organizations"] as Newtonsoft.Json.Linq.JArray).Count; + _count = (response["organizations"] as System.Text.Json.Nodes.JsonArray).Count; } catch (Exception e) { @@ -70,9 +68,9 @@ public async System.Threading.Tasks.Task Test002_Should_Return_All_Organizations ContentstackResponse contentstackResponse = await organization.GetOrganizationsAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); - _count = (response["organizations"] as Newtonsoft.Json.Linq.JArray).Count; + _count = (response["organizations"] as System.Text.Json.Nodes.JsonArray).Count; } catch (Exception e) @@ -94,9 +92,9 @@ public void Test003_Should_Return_With_Skipping_Organizations() collection.Add("skip", 4); ContentstackResponse contentstackResponse = organization.GetOrganizations(collection); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); - var count = (response["organizations"] as Newtonsoft.Json.Linq.JArray).Count; + var count = (response["organizations"] as System.Text.Json.Nodes.JsonArray).Count; } catch (Exception e) { @@ -118,7 +116,7 @@ public void Test004_Should_Return_Organization_With_UID() ContentstackResponse contentstackResponse = organization.GetOrganizations(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.IsNotNull(response["organization"], "organization"); @@ -146,7 +144,7 @@ public void Test005_Should_Return_Organization_With_UID_Include_Plan() ContentstackResponse contentstackResponse = organization.GetOrganizations(collection); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.IsNotNull(response["organization"], "organization"); AssertLogger.IsNotNull(response["organization"]["plan"], "plan"); @@ -170,7 +168,7 @@ public void Test006_Should_Return_Organization_Roles() ContentstackResponse contentstackResponse = organization.Roles(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); RoleUID = (string)response["roles"][0]["uid"]; AssertLogger.IsNotNull(response, "response"); @@ -195,7 +193,7 @@ public async System.Threading.Tasks.Task Test007_Should_Return_Organization_Role ContentstackResponse contentstackResponse = await organization.RolesAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.IsNotNull(response["roles"], "roles"); } @@ -225,9 +223,9 @@ public void Test008_Should_Add_User_To_Organization() invitation }, null); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); - AssertLogger.AreEqual(1, ((JArray)response["shares"]).Count, "sharesCount"); + AssertLogger.AreEqual(1, ((JsonArray)response["shares"]).Count, "sharesCount"); InviteID = (string)response["shares"][0]["uid"]; AssertLogger.AreEqual("The invitation has been sent successfully.", (string)response["notice"], "notice"); } @@ -257,9 +255,9 @@ public async System.Threading.Tasks.Task Test009_Should_Add_User_To_Organization invitation }, null); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); - AssertLogger.AreEqual(1, ((JArray)response["shares"]).Count, "sharesCount"); + AssertLogger.AreEqual(1, ((JsonArray)response["shares"]).Count, "sharesCount"); InviteIDAsync = (string)response["shares"][0]["uid"]; AssertLogger.AreEqual("The invitation has been sent successfully.", (string)response["notice"], "notice"); } @@ -281,7 +279,7 @@ public void Test010_Should_Resend_Invite() ContentstackResponse contentstackResponse = organization.ResendInvitation(InviteID); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.AreEqual("The invitation has been resent successfully.", (string)response["notice"], "notice"); } @@ -303,7 +301,7 @@ public async System.Threading.Tasks.Task Test011_Should_Resend_Invite() Organization organization = _client.Organization(org.Uid); ContentstackResponse contentstackResponse = await organization.ResendInvitationAsync(InviteIDAsync); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.AreEqual("The invitation has been resent successfully.", (string)response["notice"], "notice"); } @@ -326,7 +324,7 @@ public void Test012_Should_Remove_User_From_Organization() ContentstackResponse contentstackResponse = organization.RemoveUser(new System.Collections.Generic.List() { EmailSync } ); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.AreEqual("The invitation has been deleted successfully.", (string)response["notice"], "notice"); } @@ -348,7 +346,7 @@ public async System.Threading.Tasks.Task Test013_Should_Remove_User_From_Organiz Organization organization = _client.Organization(org.Uid); ContentstackResponse contentstackResponse = await organization.RemoveUserAsync(new System.Collections.Generic.List() { EmailAsync }); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.AreEqual("The invitation has been deleted successfully.", (string)response["notice"], "notice"); } @@ -371,10 +369,10 @@ public void Test014_Should_Get_All_Invites() ContentstackResponse contentstackResponse = organization.GetInvitations(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.IsNotNull(response["shares"], "shares"); - AssertLogger.AreEqual(response["shares"].GetType(), typeof(JArray), "sharesType"); + AssertLogger.AreEqual(response["shares"].GetType(), typeof(JsonArray), "sharesType"); } catch (Exception e) @@ -395,10 +393,10 @@ public async System.Threading.Tasks.Task Test015_Should_Get_All_Invites_Async() Organization organization = _client.Organization(org.Uid); ContentstackResponse contentstackResponse = await organization.GetInvitationsAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.IsNotNull(response["shares"], "shares"); - AssertLogger.AreEqual(response["shares"].GetType(), typeof(JArray), "sharesType"); + AssertLogger.AreEqual(response["shares"].GetType(), typeof(JsonArray), "sharesType"); } catch (Exception e) { @@ -419,10 +417,10 @@ public void Test016_Should_Get_All_Stacks() ContentstackResponse contentstackResponse = organization.GetStacks(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.IsNotNull(response["stacks"], "stacks"); - AssertLogger.AreEqual(response["stacks"].GetType(), typeof(JArray), "stacksType"); + AssertLogger.AreEqual(response["stacks"].GetType(), typeof(JsonArray), "stacksType"); } catch (Exception e) @@ -443,10 +441,10 @@ public async System.Threading.Tasks.Task Test017_Should_Get_All_Stacks_Async() Organization organization = _client.Organization(org.Uid); ContentstackResponse contentstackResponse = await organization.GetStacksAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); AssertLogger.IsNotNull(response["stacks"], "stacks"); - AssertLogger.AreEqual(response["stacks"].GetType(), typeof(JArray), "stacksType"); + AssertLogger.AreEqual(response["stacks"].GetType(), typeof(JsonArray), "stacksType"); } catch (Exception e) { diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack003_StackTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack003_StackTest.cs index f24258e..3703137 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack003_StackTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack003_StackTest.cs @@ -47,7 +47,7 @@ public void Test001_Should_Return_All_Stacks() ContentstackResponse contentstackResponse = stack.GetAll(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); } catch (Exception e) @@ -67,7 +67,7 @@ public async System.Threading.Tasks.Task Test002_Should_Return_All_StacksAsync() ContentstackResponse contentstackResponse = await stack.GetAllAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "response"); } catch (Exception e) @@ -87,7 +87,7 @@ public void Test003_Should_Create_Stack() Stack stack = _client.Stack(); ContentstackResponse contentstackResponse = stack.Create(_stackName, _locale, _org.Uid); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackResponse model = contentstackResponse.OpenTResponse(); Contentstack.Stack = model.Stack; TestOutputLogger.LogContext("StackApiKey", model.Stack.APIKey); @@ -115,7 +115,7 @@ public void Test004_Should_Update_Stack() Stack stack = _client.Stack(Contentstack.Stack.APIKey); ContentstackResponse contentstackResponse = stack.Update(_updatestackName); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); File.WriteAllText("./stackApiKey.txt", contentstackResponse.OpenResponse()); StackResponse model = contentstackResponse.OpenTResponse(); @@ -145,7 +145,7 @@ public async System.Threading.Tasks.Task Test005_Should_Update_Stack_Async() Stack stack = _client.Stack(Contentstack.Stack.APIKey); ContentstackResponse contentstackResponse = await stack.UpdateAsync(_updatestackName, _description); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackResponse model = contentstackResponse.OpenTResponse(); Contentstack.Stack = model.Stack; @@ -173,7 +173,7 @@ public void Test006_Should_Fetch_Stack() Stack stack = _client.Stack(Contentstack.Stack.APIKey); ContentstackResponse contentstackResponse = stack.Fetch(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackResponse model = contentstackResponse.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); @@ -200,7 +200,7 @@ public async System.Threading.Tasks.Task Test007_Should_Fetch_StackAsync() Stack stack = _client.Stack(Contentstack.Stack.APIKey); ContentstackResponse contentstackResponse = await stack.FetchAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackResponse model = contentstackResponse.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); @@ -236,7 +236,7 @@ public void Test008_Add_Stack_Settings() ContentstackResponse contentstackResponse = stack.AddSettings(settings); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackSettingsModel model = contentstackResponse.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); @@ -262,7 +262,7 @@ public void Test009_Stack_Settings() ContentstackResponse contentstackResponse = stack.Settings(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackSettingsModel model = contentstackResponse.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); @@ -288,7 +288,7 @@ public void Test010_Reset_Stack_Settings() ContentstackResponse contentstackResponse = stack.ResetSettings(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackSettingsModel model = contentstackResponse.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); @@ -321,7 +321,7 @@ public async System.Threading.Tasks.Task Test011_Add_Stack_Settings_Async() ContentstackResponse contentstackResponse = await stack.AddSettingsAsync(settings); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackSettingsModel model = contentstackResponse.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); @@ -346,7 +346,7 @@ public async System.Threading.Tasks.Task Test012_Reset_Stack_Settings_Async() ContentstackResponse contentstackResponse = await stack.ResetSettingsAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackSettingsModel model = contentstackResponse.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); @@ -372,7 +372,7 @@ public async System.Threading.Tasks.Task Test013_Stack_Settings_Async() ContentstackResponse contentstackResponse = await stack.SettingsAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); StackSettingsModel model = contentstackResponse.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack004_ReleaseTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack004_ReleaseTest.cs index f69b637..5ca7311 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack004_ReleaseTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack004_ReleaseTest.cs @@ -6,7 +6,6 @@ using Contentstack.Management.Core.Tests.Model; using Contentstack.Management.Core.Queryable; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json.Linq; using Contentstack.Management.Core.Exceptions; namespace Contentstack.Management.Core.Tests.IntegrationTest @@ -38,7 +37,7 @@ public static void ClassCleanup() [TestInitialize] public async Task Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); } @@ -168,7 +167,7 @@ private string CreateTestRelease() }; ContentstackResponse contentstackResponse = _stack.Release().Create(releaseModel); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); if (!contentstackResponse.IsSuccessStatusCode || response?["release"] == null) { @@ -195,7 +194,7 @@ public void Test001_Should_Create_Release() Assert.IsNotNull(releaseUid); ContentstackResponse contentstackResponse = _stack.Release(releaseUid).Fetch(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -239,7 +238,7 @@ private async Task CreateTestReleaseAsync() }; ContentstackResponse contentstackResponse = await _stack.Release().CreateAsync(releaseModel); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); if (!contentstackResponse.IsSuccessStatusCode || response?["release"] == null) { @@ -274,7 +273,7 @@ private List CreateSixNumberedReleases() }; ContentstackResponse contentstackResponse = _stack.Release().Create(releaseModel); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); if (!contentstackResponse.IsSuccessStatusCode || response?["release"] == null) { @@ -322,7 +321,7 @@ private async Task> CreateSixNumberedReleasesAsync() }; ContentstackResponse contentstackResponse = await _stack.Release().CreateAsync(releaseModel); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); if (!contentstackResponse.IsSuccessStatusCode || response?["release"] == null) { @@ -402,7 +401,7 @@ public async Task Test002_Should_Create_Release_Async() Assert.IsNotNull(releaseUid); ContentstackResponse contentstackResponse = await _stack.Release(releaseUid).FetchAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -440,13 +439,13 @@ public void Test003_Should_Query_All_Releases() releaseUids = CreateSixNumberedReleases(); ContentstackResponse contentstackResponse = _stack.Release().Query().Find(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); Assert.IsNotNull(response["releases"]); - var releases = response["releases"] as JArray; + var releases = response["releases"] as JsonArray; Assert.IsNotNull(releases); Assert.IsTrue(releases.Count >= 6, $"Expected at least 6 releases, but found {releases.Count}"); @@ -479,13 +478,13 @@ public async Task Test004_Should_Query_All_Releases_Async() releaseUids = await CreateSixNumberedReleasesAsync(); ContentstackResponse contentstackResponse = await _stack.Release().Query().FindAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); Assert.IsNotNull(response["releases"]); - var releases = response["releases"] as JArray; + var releases = response["releases"] as JsonArray; Assert.IsNotNull(releases); Assert.IsTrue(releases.Count >= 6, $"Expected at least 6 releases, but found {releases.Count}"); @@ -519,7 +518,7 @@ public void Test005_Should_Fetch_Release() string releaseToFetch = releaseUids[2]; ContentstackResponse contentstackResponse = _stack.Release(releaseToFetch).Fetch(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -549,7 +548,7 @@ public async Task Test006_Should_Fetch_Release_Async() string releaseToFetch = releaseUids[4]; ContentstackResponse contentstackResponse = await _stack.Release(releaseToFetch).FetchAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -586,7 +585,7 @@ public void Test007_Should_Update_Release() }; ContentstackResponse contentstackResponse = _stack.Release(releaseUid).Update(updateModel); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -631,7 +630,7 @@ public async Task Test008_Should_Update_Release_Async() }; ContentstackResponse contentstackResponse = await _stack.Release(releaseUid).UpdateAsync(updateModel); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -672,7 +671,7 @@ public void Test009_Should_Clone_Release() string cloneDescription = _testReleaseDescription + " (Cloned)"; ContentstackResponse contentstackResponse = _stack.Release(originalReleaseUid).Clone(cloneName, cloneDescription); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -726,7 +725,7 @@ public async Task Test010_Should_Clone_Release_Async() string cloneDescription = _testReleaseDescription + " (Cloned Async)"; ContentstackResponse contentstackResponse = await _stack.Release(originalReleaseUid).CloneAsync(cloneName, cloneDescription); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -778,7 +777,7 @@ public void Test011_Should_Query_Release_With_Parameters() parameters.Add("limit", "5"); ContentstackResponse contentstackResponse = _stack.Release().Query().Limit(5).Find(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -803,7 +802,7 @@ public async Task Test012_Should_Query_Release_With_Parameters_Async() parameters.Add("limit", "5"); ContentstackResponse contentstackResponse = await _stack.Release().Query().Limit(5).FindAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -834,7 +833,7 @@ public void Test013_Should_Create_Release_With_ParameterCollection() parameters.Add("include_count", "true"); ContentstackResponse contentstackResponse = _stack.Release().Create(releaseModel, parameters); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -869,7 +868,7 @@ public async Task Test014_Should_Create_Release_With_ParameterCollection_Async() parameters.Add("include_count", "true"); ContentstackResponse contentstackResponse = await _stack.Release().CreateAsync(releaseModel, parameters); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -896,7 +895,7 @@ public void Test015_Should_Get_Release_Items() releaseUid = CreateTestRelease(); ContentstackResponse contentstackResponse = _stack.Release(releaseUid).Item().GetAll(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -930,7 +929,7 @@ public async Task Test016_Should_Get_Release_Items_Async() releaseUid = await CreateTestReleaseAsync(); ContentstackResponse contentstackResponse = await _stack.Release(releaseUid).Item().GetAllAsync(); - var response = contentstackResponse.OpenJObjectResponse(); + var response = contentstackResponse.OpenJsonObjectResponse(); Assert.IsNotNull(response); Assert.IsTrue(contentstackResponse.IsSuccessStatusCode); @@ -997,7 +996,7 @@ public void Test019_Should_Delete_Release() }; ContentstackResponse createResponse = _stack.Release().Create(releaseModel); - var createResponseJson = createResponse.OpenJObjectResponse(); + var createResponseJson = createResponse.OpenJsonObjectResponse(); string releaseToDeleteUid = createResponseJson["release"]["uid"].ToString(); ContentstackResponse contentstackResponse = _stack.Release(releaseToDeleteUid).Delete(); @@ -1026,7 +1025,7 @@ public async Task Test020_Should_Delete_Release_Async() }; ContentstackResponse createResponse = await _stack.Release().CreateAsync(releaseModel); - var createResponseJson = createResponse.OpenJObjectResponse(); + var createResponseJson = createResponse.OpenJsonObjectResponse(); string releaseToDeleteUid = createResponseJson["release"]["uid"].ToString(); ContentstackResponse contentstackResponse = await _stack.Release(releaseToDeleteUid).DeleteAsync(); @@ -1059,7 +1058,7 @@ public void Test021_Should_Delete_Release_Without_Content_Type_Header() }; ContentstackResponse createResponse = _stack.Release().Create(releaseModel); - var createResponseJson = createResponse.OpenJObjectResponse(); + var createResponseJson = createResponse.OpenJsonObjectResponse(); Assert.IsTrue(createResponse.IsSuccessStatusCode, "Create release must succeed."); string releaseToDeleteUid = createResponseJson["release"]["uid"].ToString(); @@ -1103,7 +1102,7 @@ public async Task Test022_Should_Delete_Release_Async_Without_Content_Type_Heade }; ContentstackResponse createResponse = await _stack.Release().CreateAsync(releaseModel); - var createResponseJson = createResponse.OpenJObjectResponse(); + var createResponseJson = createResponse.OpenJsonObjectResponse(); Assert.IsTrue(createResponse.IsSuccessStatusCode, "Create release must succeed."); string releaseToDeleteUid = createResponseJson["release"]["uid"].ToString(); diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack011_GlobalFieldTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack011_GlobalFieldTest.cs index 76a6c82..cdb4105 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack011_GlobalFieldTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack011_GlobalFieldTest.cs @@ -34,9 +34,9 @@ public static void ClassCleanup() [TestInitialize] public void Initialize () { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); - _modelling = Contentstack.serialize(_client.serializer, "globalfield.json"); + _modelling = Contentstack.serialize(_client.SerializerOptions, "globalfield.json"); } [TestMethod] @@ -190,7 +190,7 @@ public async System.Threading.Tasks.Task Test009_Should_Delete_Async_Global_Fiel TestOutputLogger.LogContext("TestScenario", "DeleteAsyncGlobalField"); // Create a new global field for async delete test - ContentModelling deleteModel = Contentstack.serialize(_client.serializer, "globalfield.json"); + ContentModelling deleteModel = Contentstack.serialize(_client.SerializerOptions, "globalfield.json"); deleteModel.Uid = "test_delete_async"; deleteModel.Title = "Test Delete Async"; ContentstackResponse createResponse = _stack.GlobalField().Create(deleteModel); @@ -280,7 +280,7 @@ private static void AssertGlobalFieldNotFoundError(Exception ex, string assertCo private ContentModelling CreateInvalidGlobalFieldModel(string scenario) { - var model = Contentstack.serialize(_client.serializer, "globalfield.json"); + var model = Contentstack.serialize(_client.SerializerOptions, "globalfield.json"); switch (scenario) { @@ -764,7 +764,7 @@ public void Test034_Should_Fail_Create_With_Extremely_Long_Title() public void Test035_Should_Fail_Create_With_Special_Characters_In_UID() { TestOutputLogger.LogContext("TestScenario", "CreateGlobalField_SpecialCharactersUID"); - var invalidModel = Contentstack.serialize(_client.serializer, "globalfield.json"); + var invalidModel = Contentstack.serialize(_client.SerializerOptions, "globalfield.json"); invalidModel.Uid = "invalid@uid#with$special%characters"; try diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_ContentTypeTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_ContentTypeTest.cs index 3cdd893..9aa16bd 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_ContentTypeTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_ContentTypeTest.cs @@ -9,7 +9,6 @@ using Contentstack.Management.Core.Tests.Helpers; using Contentstack.Management.Core.Tests.Model; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json.Linq; // Resolve ambiguous reference between System.Action and Contentstack.Management.Core.Models.Fields.Action using SystemAction = System.Action; @@ -40,10 +39,10 @@ public static void ClassCleanup() [TestInitialize] public void Initialize () { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); - _singlePage = Contentstack.serialize(_client.serializer, "singlepageCT.json"); - _multiPage = Contentstack.serialize(_client.serializer, "multiPageCT.json"); + _singlePage = Contentstack.serialize(_client.SerializerOptions, "singlepageCT.json"); + _multiPage = Contentstack.serialize(_client.SerializerOptions, "multiPageCT.json"); } [TestMethod] @@ -112,7 +111,7 @@ public void Test005_Should_Update_Content_Type() { TestOutputLogger.LogContext("TestScenario", "UpdateContentType"); TestOutputLogger.LogContext("ContentType", _multiPage.Uid); - _multiPage.Schema = Contentstack.serializeArray>(_client.serializer, "contentTypeSchema.json"); ; + _multiPage.Schema = Contentstack.serializeArray>(_client.SerializerOptions, "contentTypeSchema.json"); ; ContentstackResponse response = _stack.ContentType(_multiPage.Uid).Update(_multiPage); ContentTypeModel ContentType = response.OpenTResponse(); AssertLogger.IsNotNull(response, "response"); @@ -132,7 +131,7 @@ public async System.Threading.Tasks.Task Test006_Should_Update_Async_Content_Typ try { // Load the existing schema - _multiPage.Schema = Contentstack.serializeArray>(_client.serializer, "contentTypeSchema.json"); + _multiPage.Schema = Contentstack.serializeArray>(_client.SerializerOptions, "contentTypeSchema.json"); // Add a new text field to the schema var newTextField = new Models.Fields.TextboxField diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs index 5b2785e..9f71274 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs @@ -69,7 +69,7 @@ public static void ClassCleanup() [TestInitialize] public void Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); } @@ -2403,7 +2403,7 @@ public void Test075_Should_Handle_Partial_Resource_State() if (response.IsSuccessStatusCode) { - var jsonResponse = response.OpenJObjectResponse(); + var jsonResponse = response.OpenJsonObjectResponse(); // Check if essential fields are present var uid = jsonResponse?["global_field"]?["uid"]?.ToString(); @@ -2545,7 +2545,7 @@ public void Test079_Should_Handle_Invalid_Resource_Timestamps() if (response.IsSuccessStatusCode) { - var jsonResponse = response.OpenJObjectResponse(); + var jsonResponse = response.OpenJsonObjectResponse(); // Check timestamp consistency var createdAt = jsonResponse?["global_field"]?["created_at"]?.ToString(); diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012b_ContentTypeExpandedIntegrationTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012b_ContentTypeExpandedIntegrationTest.cs index 087b2ed..70fb0df 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012b_ContentTypeExpandedIntegrationTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012b_ContentTypeExpandedIntegrationTest.cs @@ -40,7 +40,7 @@ public static void ClassCleanup() [TestInitialize] public void TestInitialize() { - var response = StackResponse.getStack(_client.serializer); + var response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); } @@ -51,7 +51,7 @@ public void TestInitialize() public void Test001_Should_DisposableSimple_FullLifecycle_Sync() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); try { TestOutputLogger.LogContext("TestScenario", "DisposableSimple_Sync"); @@ -101,7 +101,7 @@ public void Test001_Should_DisposableSimple_FullLifecycle_Sync() public async Task Test002_Should_DisposableSimple_FullLifecycle_Async() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); try { TestOutputLogger.LogContext("TestScenario", "DisposableSimple_Async"); @@ -146,7 +146,7 @@ await AssertLogger.ThrowsContentstackErrorAsync( public void Test003_Should_DisposableSimple_Delete_Sync() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); _stack.ContentType().Create(model); try { @@ -164,7 +164,7 @@ public void Test003_Should_DisposableSimple_Delete_Sync() public async Task Test004_Should_DisposableSimple_Delete_Async() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); await _stack.ContentType().CreateAsync(model); try { @@ -186,7 +186,7 @@ public async Task Test004_Should_DisposableSimple_Delete_Async() public void Test005_Should_Error_Create_DuplicateUid_Sync() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); _stack.ContentType().Create(model); try { @@ -207,7 +207,7 @@ public void Test005_Should_Error_Create_DuplicateUid_Sync() public async Task Test006_Should_Error_Create_DuplicateUid_Async() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); await _stack.ContentType().CreateAsync(model); try { @@ -228,7 +228,7 @@ await AssertLogger.ThrowsContentstackErrorAsync( public void Test007_Should_Error_Create_InvalidUid_Sync() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); model.Uid = "Invalid-UID-Caps!"; AssertLogger.ThrowsContentstackError( () => _stack.ContentType().Create(model), @@ -242,7 +242,7 @@ public void Test007_Should_Error_Create_InvalidUid_Sync() public async Task Test008_Should_Error_Create_InvalidUid_Async() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); model.Uid = "Invalid-UID-Caps!"; await AssertLogger.ThrowsContentstackErrorAsync( async () => await _stack.ContentType().CreateAsync(model), @@ -309,7 +309,7 @@ await AssertLogger.ThrowsContentstackErrorAsync( [DoNotParallelize] public void Test013_Should_Error_Update_NonExistent_Sync() { - var m = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", NewSuffix()); + var m = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", NewSuffix()); AssertLogger.ThrowsContentstackError( () => _stack.ContentType("non_existent_ct_" + NewSuffix()).Update(m), "UpdateMissing", @@ -321,7 +321,7 @@ public void Test013_Should_Error_Update_NonExistent_Sync() [DoNotParallelize] public async Task Test014_Should_Error_Update_NonExistent_Async() { - var m = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", NewSuffix()); + var m = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", NewSuffix()); await AssertLogger.ThrowsContentstackErrorAsync( async () => await _stack.ContentType("non_existent_ct_" + NewSuffix()).UpdateAsync(m), "UpdateMissingAsync", @@ -360,7 +360,7 @@ await AssertLogger.ThrowsContentstackErrorAsync( public void Test017_Should_ComplexFixture_CreateFetch_AssertStructure_Sync() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeComplex.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeComplex.json", sfx); try { _stack.ContentType().Create(model); @@ -399,7 +399,7 @@ public void Test017_Should_ComplexFixture_CreateFetch_AssertStructure_Sync() public async Task Test018_Should_ComplexFixture_CreateFetch_AssertStructure_Async() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeComplex.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeComplex.json", sfx); try { await _stack.ContentType().CreateAsync(model); @@ -417,7 +417,7 @@ public async Task Test018_Should_ComplexFixture_CreateFetch_AssertStructure_Asyn public void Test019_Should_MediumFixture_CreateFetch_AssertFieldTypes_Sync() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeMedium.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeMedium.json", sfx); try { _stack.ContentType().Create(model); @@ -448,7 +448,7 @@ public void Test019_Should_MediumFixture_CreateFetch_AssertFieldTypes_Sync() public async Task Test020_Should_MediumFixture_CreateFetch_AssertFieldTypes_Async() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeMedium.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeMedium.json", sfx); try { await _stack.ContentType().CreateAsync(model); @@ -473,7 +473,7 @@ public void Test021_Should_ExtensionField_CreateFetch_AfterUpload_Sync() extUid = UploadDisposableCustomFieldExtensionAndGetUid(sfx); TestOutputLogger.LogContext("ExtensionUid", extUid ?? ""); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); ctUid = model.Uid; model.Schema.Add(new ExtensionField { @@ -509,7 +509,7 @@ public async Task Test022_Should_ExtensionField_CreateFetch_AfterUpload_Async() extUid = await UploadDisposableCustomFieldExtensionAndGetUidAsync(sfx); TestOutputLogger.LogContext("ExtensionUid", extUid ?? ""); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); ctUid = model.Uid; model.Schema.Add(new ExtensionField { @@ -656,7 +656,7 @@ await AssertLogger.ThrowsContentstackErrorAsync( public void Test027_Should_Error_Create_ContentType_ExtensionField_NonExistentExtension_Sync() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); try { model.Schema.Add(new ExtensionField @@ -685,7 +685,7 @@ public void Test027_Should_Error_Create_ContentType_ExtensionField_NonExistentEx public async Task Test028_Should_Error_Create_ContentType_ExtensionField_NonExistentExtension_Async() { var sfx = NewSuffix(); - var model = ContentTypeFixtureLoader.LoadFromMock(_client.serializer, "contentTypeSimple.json", sfx); + var model = ContentTypeFixtureLoader.LoadFromMock(_client.SerializerOptions, "contentTypeSimple.json", sfx); try { model.Schema.Add(new ExtensionField @@ -834,7 +834,7 @@ private static string ResolveCustomUploadHtmlPath() private static string ParseExtensionUidFromUploadResponse(ContentstackResponse response) { - var jo = response.OpenJObjectResponse(); + var jo = response.OpenJsonObjectResponse(); var token = jo["extension"]?["uid"] ?? jo["uid"]; return token?.ToString(); } diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack013_AssetTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack013_AssetTest.cs index 7189c1e..c21661d 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack013_AssetTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack013_AssetTest.cs @@ -8,6 +8,8 @@ using System.Threading; using System.Threading.Tasks; using System.Text; +using System.Text.Json.Nodes; +using System.Text.Json; using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Models.CustomExtension; using Contentstack.Management.Core.Tests.Helpers; @@ -46,7 +48,7 @@ public static void ClassCleanup() [TestInitialize] public void Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); } @@ -308,7 +310,7 @@ private static void CleanupTestAssets(List assetUIDs) try { - var stack = _client.Stack(StackResponse.getStack(_client.serializer).Stack.APIKey); + var stack = _client.Stack(StackResponse.getStack(_client.SerializerOptions).Stack.APIKey); foreach (var uid in assetUIDs) { try @@ -502,10 +504,10 @@ public async Task Test005_Should_Create_Asset_Async() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.Created, response.StatusCode, "CreateAssetAsync_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); if (responseObject["asset"] != null) { - _testAssetUid = responseObject["asset"]["uid"]?.ToString(); + _testAssetUid = responseObject["asset"]?["uid"]?.GetValue(); TestOutputLogger.LogContext("AssetUID", _testAssetUid ?? "null"); } } @@ -540,7 +542,7 @@ public async Task Test006_Should_Fetch_Asset() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "FetchAsset_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "FetchAsset_ResponseContainsAsset"); } else @@ -575,7 +577,7 @@ public async Task Test007_Should_Fetch_Asset_Async() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "FetchAssetAsync_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "FetchAssetAsync_ResponseContainsAsset"); } else @@ -613,7 +615,7 @@ public async Task Test008_Should_Update_Asset() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "UpdateAsset_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "UpdateAsset_ResponseContainsAsset"); } else @@ -651,7 +653,7 @@ public async Task Test009_Should_Update_Asset_Async() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "UpdateAssetAsync_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "UpdateAssetAsync_ResponseContainsAsset"); } else @@ -679,7 +681,7 @@ public async Task Test010_Should_Query_Assets() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "QueryAssets_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["assets"], "QueryAssets_ResponseContainsAssets"); } else @@ -710,7 +712,7 @@ public async Task Test011_Should_Query_Assets_With_Parameters() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "QueryAssetsWithParams_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["assets"], "QueryAssetsWithParams_ResponseContainsAssets"); } else @@ -772,8 +774,8 @@ public async Task Test013_Should_Delete_Asset_Async() if (createResponse.IsSuccessStatusCode) { - var responseObject = createResponse.OpenJObjectResponse(); - string assetUid = responseObject["asset"]["uid"]?.ToString(); + var responseObject = createResponse.OpenJsonObjectResponse(); + string assetUid = responseObject["asset"]?["uid"]?.GetValue(); TestOutputLogger.LogContext("AssetUID", assetUid ?? "null"); if (!string.IsNullOrEmpty(assetUid)) @@ -817,10 +819,10 @@ public async Task Test014_Should_Create_Folder() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.Created, response.StatusCode, "CreateFolder_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); if (responseObject["asset"] != null) { - _testFolderUid = responseObject["asset"]["uid"]?.ToString(); + _testFolderUid = responseObject["asset"]?["uid"]?.GetValue(); TestOutputLogger.LogContext("FolderUID", _testFolderUid ?? "null"); } } @@ -855,7 +857,7 @@ public async Task Test015_Should_Create_Subfolder() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.Created, response.StatusCode, "CreateSubfolder_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "CreateSubfolder_ResponseContainsFolder"); } else @@ -890,7 +892,7 @@ public async Task Test016_Should_Fetch_Folder() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "FetchFolder_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "FetchFolder_ResponseContainsFolder"); } else @@ -925,7 +927,7 @@ public async Task Test017_Should_Fetch_Folder_Async() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "FetchFolderAsync_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "FetchFolderAsync_ResponseContainsFolder"); } else @@ -960,7 +962,7 @@ public async Task Test018_Should_Update_Folder() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.Created, response.StatusCode, "UpdateFolder_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "UpdateFolder_ResponseContainsFolder"); } else @@ -996,7 +998,7 @@ public async Task Test019_Should_Update_Folder_Async() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.Created, response.StatusCode, "UpdateFolderAsync_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "UpdateFolderAsync_ResponseContainsFolder"); } else @@ -1059,8 +1061,8 @@ public async Task Test023_Should_Delete_Folder_Async() if (createResponse.IsSuccessStatusCode) { - var responseObject = createResponse.OpenJObjectResponse(); - string folderUid = responseObject["asset"]["uid"]?.ToString(); + var responseObject = createResponse.OpenJsonObjectResponse(); + string folderUid = responseObject["asset"]?["uid"]?.GetValue(); TestOutputLogger.LogContext("FolderUID", folderUid ?? "null"); if (!string.IsNullOrEmpty(folderUid)) @@ -1265,7 +1267,7 @@ public async Task Test030_Should_Handle_Empty_Query_Results() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "EmptyQuery_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["assets"], "EmptyQuery_ResponseContainsAssets"); // Empty results are valid, so we don't assert on count } @@ -1302,7 +1304,7 @@ public async Task Test031_Should_Fetch_Asset_With_Locale_Parameter() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "FetchAssetWithLocale_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "FetchAssetWithLocale_ResponseContainsAsset"); } else @@ -1339,7 +1341,7 @@ public async Task Test032_Should_Fetch_Asset_Async_With_Locale_Parameter() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "FetchAssetAsyncWithLocale_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "FetchAssetAsyncWithLocale_ResponseContainsAsset"); } else @@ -1373,7 +1375,7 @@ public async Task Test033_Should_Query_Assets_With_Locale_Parameter() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "QueryAssetsWithLocale_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["assets"], "QueryAssetsWithLocale_ResponseContainsAssets"); } else @@ -1414,7 +1416,7 @@ public async Task Test034_Should_Handle_Fetch_With_Invalid_Locale_Parameter() ContentstackResponse response = _stack.Asset(_testAssetUid).Fetch(coll); if (response.IsSuccessStatusCode) { - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["asset"], "FetchInvalidLocale_ResponseContainsAssetWhenApiIgnoresParam"); } } @@ -1476,7 +1478,7 @@ public async Task Test036_Should_Handle_Query_With_Invalid_Locale_Parameter() if (response.IsSuccessStatusCode) { AssertLogger.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode, "QueryInvalidLocale_StatusCode"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["assets"], "QueryInvalidLocale_ResponseContainsAssetsWhenApiIgnoresParam"); } } @@ -1643,8 +1645,8 @@ public async Task Test044_Should_Fail_With_XSS_Attempts_In_Asset_Data() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ XSS attempt in asset title was not rejected"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -1680,8 +1682,8 @@ public async Task Test045_Should_Validate_Asset_Title_Length_Limits() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Extremely long title was accepted - no length validation"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -1718,8 +1720,8 @@ public async Task Test046_Should_Validate_Asset_Description_Boundaries() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Extremely long description was accepted"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -1763,8 +1765,8 @@ public async Task Test047_Should_Handle_Special_Characters_In_Asset_Names() if (response.IsSuccessStatusCode) { Console.WriteLine($"⚠️ Special character filename accepted: '{fileName}'"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -1808,8 +1810,8 @@ public async Task Test048_Should_Validate_Asset_Tag_Format_And_Limits() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Extremely long tags were accepted"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -1845,8 +1847,8 @@ public async Task Test049_Should_Handle_Unicode_And_Emoji_In_Asset_Metadata() if (response.IsSuccessStatusCode) { Console.WriteLine("✅ Unicode and emoji characters were properly handled"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -1893,8 +1895,8 @@ public async Task Test050_Should_Block_Malicious_File_Extensions() if (response.IsSuccessStatusCode) { Console.WriteLine($"⚠️ Malicious file extension accepted: {extension}"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -1938,8 +1940,8 @@ public async Task Test051_Should_Validate_File_MIME_Type_Consistency() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ MIME type mismatch was not detected"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -1983,8 +1985,8 @@ public async Task Test052_Should_Handle_Oversized_File_Uploads() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Large file was accepted - no size limits detected"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2022,8 +2024,8 @@ public async Task Test053_Should_Block_Executable_File_Uploads() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Executable file was accepted"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2064,8 +2066,8 @@ public async Task Test054_Should_Validate_File_Content_Against_Extension() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Disguised executable was not detected"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2105,8 +2107,8 @@ public async Task Test055_Should_Handle_Corrupted_File_Uploads() if (response.IsSuccessStatusCode) { Console.WriteLine($"ℹ️ Corrupted file accepted: {corruptionType}"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2153,8 +2155,8 @@ public async Task Test056_Should_Block_Files_With_Malicious_Headers() if (response.IsSuccessStatusCode) { Console.WriteLine($"⚠️ File with malicious header accepted: {header.Key}"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2194,8 +2196,8 @@ public async Task Test057_Should_Validate_Image_File_Integrity() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Fake image file was accepted without validation"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2231,8 +2233,8 @@ public async Task Test058_Should_Handle_Zero_Byte_File_Uploads() if (response.IsSuccessStatusCode) { Console.WriteLine("ℹ️ Zero-byte file was accepted"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2280,8 +2282,8 @@ End of document. if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ File with embedded script was accepted"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2367,8 +2369,8 @@ public async Task Test061_Should_Fail_With_Insufficient_Asset_Permissions() else { Console.WriteLine("⚠️ Operation succeeded with limited permissions token - may not have proper permission validation"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2539,8 +2541,8 @@ public async Task Test066_Should_Handle_Session_Timeout_During_Upload() else { Console.WriteLine("⚠️ Session timeout scenario not triggered - may need actual expired token"); - var responseObj = response2.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response2.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2621,8 +2623,8 @@ public async Task Test068_Should_Handle_Concurrent_Auth_Context_Loss() // Track successful assets for cleanup foreach (var result in results.Where(r => r.IsSuccessStatusCode)) { - var responseObj = result.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = result.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2724,8 +2726,8 @@ public async Task Test070_Should_Handle_Concurrent_Asset_Modifications() return; } - var responseObj = createResponse.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = createResponse.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (string.IsNullOrEmpty(assetUID)) { Console.WriteLine("Could not get asset UID for concurrent test"); @@ -2781,8 +2783,8 @@ public async Task Test071_Should_Detect_Asset_State_Conflicts() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = createResponse.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2829,8 +2831,8 @@ public async Task Test072_Should_Handle_Folder_Hierarchy_Corruption() else { Console.WriteLine("⚠️ Asset created in non-existent folder - hierarchy validation may be insufficient"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2860,8 +2862,8 @@ public async Task Test073_Should_Validate_Asset_Metadata_Consistency() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = createResponse.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -2872,8 +2874,8 @@ public async Task Test073_Should_Validate_Asset_Metadata_Consistency() var fetchResponse = _stack.Asset(assetUID).Fetch(); if (fetchResponse.IsSuccessStatusCode) { - var fetchedObj = fetchResponse.OpenJObjectResponse(); - var fetchedTitle = fetchedObj["asset"]?["title"]?.ToString(); + var fetchedObj = fetchResponse.OpenJsonObjectResponse(); + var fetchedTitle = fetchedObj["asset"]?["title"]?.GetValue(); if (fetchedTitle == "Metadata Test") { @@ -2932,8 +2934,8 @@ public async Task Test075_Should_Detect_Circular_Folder_References() if (folder1Response.IsSuccessStatusCode) { - var folder1Obj = folder1Response.OpenJObjectResponse(); - var folder1UID = folder1Obj["asset"]?["uid"]?.ToString(); + var folder1Obj = folder1Response.OpenJsonObjectResponse(); + var folder1UID = folder1Obj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(folder1UID)) { @@ -2944,8 +2946,8 @@ public async Task Test075_Should_Detect_Circular_Folder_References() if (circularResponse.IsSuccessStatusCode) { - var folder2Obj = circularResponse.OpenJObjectResponse(); - var folder2UID = folder2Obj["asset"]?["uid"]?.ToString(); + var folder2Obj = circularResponse.OpenJsonObjectResponse(); + var folder2UID = folder2Obj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(folder2UID)) { _testFolderUIDs.Add(folder2UID); @@ -2982,8 +2984,8 @@ public async Task Test076_Should_Handle_Asset_Version_Conflicts() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = createResponse.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3034,8 +3036,8 @@ public async Task Test077_Should_Validate_Asset_Parent_Folder_Existence() else { Console.WriteLine("⚠️ Asset created with invalid parent folder - validation may be insufficient"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3084,8 +3086,8 @@ public async Task Test078_Should_Handle_Race_Conditions_In_Asset_Creation() // Track successful assets for cleanup foreach (var result in results.Where(r => r.IsSuccessStatusCode)) { - var responseObj = result.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = result.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3115,8 +3117,8 @@ public async Task Test079_Should_Manage_Asset_Locking_During_Updates() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = createResponse.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3176,8 +3178,8 @@ public async Task Test080_Should_Handle_Network_Timeout_During_Upload() if (result.IsSuccessStatusCode) { Console.WriteLine("⚠️ Upload completed before timeout - network too fast for timeout simulation"); - var responseObj = result.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = result.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3227,8 +3229,8 @@ public async Task Test081_Should_Handle_Upload_Interruption_And_Resume() if (result.IsSuccessStatusCode) { Console.WriteLine("✅ Upload completed despite simulated interruption"); - var responseObj = result.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = result.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3373,8 +3375,8 @@ public async Task Test084_Should_Handle_Partial_Upload_Failures() // Track successful assets for cleanup foreach (var result in results.Where(r => r.IsSuccessStatusCode)) { - var responseObj = result.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = result.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3648,8 +3650,8 @@ public async Task Test090_Should_Handle_Maximum_File_Size_Limits() if (response.IsSuccessStatusCode) { Console.WriteLine("ℹ️ Large file (10MB) was accepted - size limit is higher than 10MB"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3697,8 +3699,8 @@ public async Task Test091_Should_Handle_Maximum_Asset_Count_Per_Stack() if (response.IsSuccessStatusCode) { createdAssets++; - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3745,8 +3747,8 @@ public async Task Test092_Should_Handle_Maximum_Folder_Depth_Limits() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); - var folderUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var folderUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(folderUID)) { _testFolderUIDs.Add(folderUID); @@ -3796,8 +3798,8 @@ public async Task Test093_Should_Handle_Storage_Quota_Exceeded() if (response.IsSuccessStatusCode) { Console.WriteLine($" Quota test file {i} uploaded successfully"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3864,8 +3866,8 @@ public async Task Test094_Should_Handle_Memory_Pressure_During_Processing() // Track successful assets for cleanup foreach (var result in results.Where(r => r.IsSuccessStatusCode)) { - var responseObj = result.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = result.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -3915,8 +3917,8 @@ public async Task Test095_Should_Handle_CPU_Intensive_Image_Processing() if (response.IsSuccessStatusCode) { Console.WriteLine($"✅ CPU intensive processing completed in {stopwatch.ElapsedMilliseconds}ms"); - var responseObj = response.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = response.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -4014,8 +4016,8 @@ public async Task Test097_Should_Handle_Concurrent_Upload_Limits() // Track successful assets for cleanup foreach (var result in results.Where(r => r.IsSuccessStatusCode)) { - var responseObj = result.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = result.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); @@ -4130,8 +4132,8 @@ public async Task Test099_Should_Handle_Asset_Processing_Queue_Overflow() // Track successful assets for cleanup foreach (var result in results.Where(r => r.IsSuccessStatusCode)) { - var responseObj = result.OpenJObjectResponse(); - var assetUID = responseObj["asset"]?["uid"]?.ToString(); + var responseObj = result.OpenJsonObjectResponse(); + var assetUID = responseObj["asset"]?["uid"]?.GetValue(); if (!string.IsNullOrEmpty(assetUID)) { _testAssetUIDs.Add(assetUID); diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack014_EntryTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack014_EntryTest.cs index 34cd1f5..38def35 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack014_EntryTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack014_EntryTest.cs @@ -15,9 +15,6 @@ using Contentstack.Management.Core.Tests.Helpers; using Contentstack.Management.Core.Tests.Model; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; -using Newtonsoft.Json.Linq; - namespace Contentstack.Management.Core.Tests.IntegrationTest { @@ -54,7 +51,7 @@ public static void ClassCleanup() [TestInitialize] public void Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); } @@ -373,7 +370,7 @@ private static void CleanupTestEntries(List entryUIDs, string contentTyp try { - var stack = _client.Stack(StackResponse.getStack(_client.serializer).Stack.APIKey); + var stack = _client.Stack(StackResponse.getStack(_client.SerializerOptions).Stack.APIKey); foreach (var uid in entryUIDs.ToList()) { try @@ -529,10 +526,10 @@ public async System.Threading.Tasks.Task Test001_Should_Create_Entry() if (response.IsSuccessStatusCode) { - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["entry"], "responseObject_entry"); - var entryData = responseObject["entry"] as Newtonsoft.Json.Linq.JObject; + var entryData = responseObject["entry"] as JsonObject; AssertLogger.IsNotNull(entryData["uid"], "entry_uid"); AssertLogger.AreEqual(singlePageEntry.Title, entryData["title"]?.ToString(), "Entry title should match", "entry_title"); AssertLogger.AreEqual(singlePageEntry.Url, entryData["url"]?.ToString(), "Entry URL should match", "entry_url"); @@ -616,10 +613,10 @@ public async System.Threading.Tasks.Task Test002_Should_Create_MultiPage_Entry() if (response.IsSuccessStatusCode) { - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["entry"], "responseObject_entry"); - var entryData = responseObject["entry"] as Newtonsoft.Json.Linq.JObject; + var entryData = responseObject["entry"] as JsonObject; AssertLogger.IsNotNull(entryData["uid"], "entry_uid"); AssertLogger.AreEqual(multiPageEntry.Title, entryData["title"]?.ToString(), "Entry title should match", "entry_title"); AssertLogger.AreEqual(multiPageEntry.Url, entryData["url"]?.ToString(), "Entry URL should match", "entry_url"); @@ -657,7 +654,7 @@ public async System.Threading.Tasks.Task Test003_Should_Fetch_Entry() if (createResponse.IsSuccessStatusCode) { - var createObject = createResponse.OpenJObjectResponse(); + var createObject = createResponse.OpenJsonObjectResponse(); var entryUid = createObject["entry"]["uid"]?.ToString(); AssertLogger.IsNotNull(entryUid, "created_entry_uid"); TestOutputLogger.LogContext("Entry", entryUid); @@ -666,10 +663,10 @@ public async System.Threading.Tasks.Task Test003_Should_Fetch_Entry() if (fetchResponse.IsSuccessStatusCode) { - var fetchObject = fetchResponse.OpenJObjectResponse(); + var fetchObject = fetchResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(fetchObject["entry"], "fetchObject_entry"); - var entryData = fetchObject["entry"] as Newtonsoft.Json.Linq.JObject; + var entryData = fetchObject["entry"] as JsonObject; AssertLogger.AreEqual(entryUid, entryData["uid"]?.ToString(), "Fetched entry UID should match", "fetched_entry_uid"); AssertLogger.AreEqual(singlePageEntry.Title, entryData["title"]?.ToString(), "Fetched entry title should match", "fetched_entry_title"); @@ -711,7 +708,7 @@ public async System.Threading.Tasks.Task Test004_Should_Update_Entry() if (createResponse.IsSuccessStatusCode) { - var createObject = createResponse.OpenJObjectResponse(); + var createObject = createResponse.OpenJsonObjectResponse(); var entryUid = createObject["entry"]["uid"]?.ToString(); AssertLogger.IsNotNull(entryUid, "created_entry_uid"); TestOutputLogger.LogContext("Entry", entryUid); @@ -728,10 +725,10 @@ public async System.Threading.Tasks.Task Test004_Should_Update_Entry() if (updateResponse.IsSuccessStatusCode) { - var updateObject = updateResponse.OpenJObjectResponse(); + var updateObject = updateResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(updateObject["entry"], "updateObject_entry"); - var entryData = updateObject["entry"] as Newtonsoft.Json.Linq.JObject; + var entryData = updateObject["entry"] as JsonObject; AssertLogger.AreEqual(entryUid, entryData["uid"]?.ToString(), "Updated entry UID should match", "updated_entry_uid"); AssertLogger.AreEqual(updatedEntry.Title, entryData["title"]?.ToString(), "Updated entry title should match", "updated_entry_title"); AssertLogger.AreEqual(updatedEntry.Url, entryData["url"]?.ToString(), "Updated entry URL should match", "updated_entry_url"); @@ -766,10 +763,10 @@ public async System.Threading.Tasks.Task Test005_Should_Query_Entries() if (response.IsSuccessStatusCode) { - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["entries"], "responseObject_entries"); - var entries = responseObject["entries"] as Newtonsoft.Json.Linq.JArray; + var entries = responseObject["entries"] as System.Text.Json.Nodes.JsonArray; AssertLogger.IsNotNull(entries, "entries_array"); Console.WriteLine($"Successfully queried {entries.Count} entries for single_page content type"); @@ -804,7 +801,7 @@ public async System.Threading.Tasks.Task Test006_Should_Delete_Entry() if (createResponse.IsSuccessStatusCode) { - var createObject = createResponse.OpenJObjectResponse(); + var createObject = createResponse.OpenJsonObjectResponse(); var entryUid = createObject["entry"]["uid"]?.ToString(); AssertLogger.IsNotNull(entryUid, "created_entry_uid"); TestOutputLogger.LogContext("Entry", entryUid); @@ -851,7 +848,7 @@ public async Task Test020_Should_Fail_With_Null_Entry_Parameters() else { Console.WriteLine("⚠️ Null title was accepted - validation may be insufficient"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -924,7 +921,7 @@ public async Task Test021_Should_Fail_With_Invalid_Entry_UID_Formats() { Console.WriteLine($"✅ SDK validation caught malformed UID: {ex.Message}"); } - catch (JsonReaderException ex) + catch (JsonException ex) { // API returned HTML error page instead of JSON for path traversal/malicious UIDs Console.WriteLine($"✅ API blocked malicious entry UID with HTML response: {invalidUID}"); @@ -1010,7 +1007,7 @@ public async Task Test024_Should_Fail_With_XSS_Attempts_In_Entry_Data() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ XSS attempt in entry title was not rejected"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1047,7 +1044,7 @@ public async Task Test025_Should_Validate_Entry_Field_Length_Limits() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Extremely long title was accepted - no length validation"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1101,7 +1098,7 @@ public async Task Test026_Should_Handle_Invalid_Content_Type_UIDs() else { Console.WriteLine($"⚠️ Invalid content type was accepted: '{invalidContentType}'"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1118,7 +1115,7 @@ public async Task Test026_Should_Handle_Invalid_Content_Type_UIDs() { Console.WriteLine($"✅ SDK caught invalid content type: {ex.Message}"); } - catch (JsonReaderException ex) + catch (JsonException ex) { // API returned HTML error page instead of JSON for special characters/malicious content types Console.WriteLine($"✅ API blocked malicious content type UID with HTML response: {invalidContentType}"); @@ -1159,7 +1156,7 @@ public async Task Test027_Should_Handle_Special_Characters_In_Entry_Fields() if (response.IsSuccessStatusCode) { Console.WriteLine($"ℹ️ Special character title accepted: '{title.Replace("\0", "\\0").Replace("\n", "\\n").Replace("\r", "\\r").Replace("\t", "\\t")}'"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1213,7 +1210,7 @@ public async Task Test028_Should_Validate_Required_Field_Constraints() else { Console.WriteLine("⚠️ Entry created without required field - validation may be insufficient"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1252,7 +1249,7 @@ public async Task Test029_Should_Handle_Unicode_And_Emoji_In_Entry_Data() if (response.IsSuccessStatusCode) { Console.WriteLine("✅ Unicode and emoji characters were properly handled"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1296,7 +1293,7 @@ public async Task Test030_Should_Block_Script_Injection_In_Entry_Fields() if (response.IsSuccessStatusCode) { Console.WriteLine("⚠️ Script injection attempt was not blocked"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1334,7 +1331,7 @@ public async Task Test031_Should_Validate_Entry_Field_Data_Types() if (response.IsSuccessStatusCode) { Console.WriteLine("ℹ️ Entry with control characters was accepted"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1383,7 +1380,7 @@ public async Task Test032_Should_Handle_Malformed_JSON_In_Entry_Data() if (response.IsSuccessStatusCode) { Console.WriteLine("✅ SDK properly handled entry serialization"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1433,7 +1430,7 @@ public async Task Test033_Should_Block_HTML_Injection_In_Text_Fields() if (response.IsSuccessStatusCode) { Console.WriteLine($"⚠️ HTML injection not blocked: '{htmlPayload}'"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1483,7 +1480,7 @@ public async Task Test034_Should_Validate_Entry_Schema_Compliance() if (response.IsSuccessStatusCode) { Console.WriteLine("✅ Entry schema validation passed"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1523,7 +1520,7 @@ public async Task Test035_Should_Handle_Invalid_Reference_Field_Values() if (response.IsSuccessStatusCode) { Console.WriteLine("✅ Base entry created for reference testing"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1591,7 +1588,7 @@ public async Task Test036_Should_Block_Malicious_File_References() if (response.IsSuccessStatusCode) { Console.WriteLine($"⚠️ Malicious file reference not blocked: '{maliciousPath}'"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1647,7 +1644,7 @@ public async Task Test037_Should_Validate_Entry_Field_Format_Rules() if (response.IsSuccessStatusCode) { Console.WriteLine($"ℹ️ URL format accepted: '{invalidUrl}'"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1693,7 +1690,7 @@ public async Task Test038_Should_Handle_Circular_Reference_Prevention() if (response1.IsSuccessStatusCode) { - var responseObj1 = response1.OpenJObjectResponse(); + var responseObj1 = response1.OpenJsonObjectResponse(); var entryUID1 = responseObj1["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID1)) { @@ -1710,7 +1707,7 @@ public async Task Test038_Should_Handle_Circular_Reference_Prevention() if (response2.IsSuccessStatusCode) { - var responseObj2 = response2.OpenJObjectResponse(); + var responseObj2 = response2.OpenJsonObjectResponse(); var entryUID2 = responseObj2["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID2)) { @@ -1748,7 +1745,7 @@ public async Task Test039_Should_Validate_Entry_Version_Integrity() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1856,7 +1853,7 @@ public async Task Test041_Should_Fail_With_Insufficient_Entry_Permissions() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -1988,7 +1985,7 @@ public async Task Test044_Should_Validate_Content_Type_Access_Permissions() else { Console.WriteLine("⚠️ Restricted content type access was allowed"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2023,7 +2020,7 @@ public async Task Test045_Should_Block_Unauthorized_Entry_Publishing() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2084,7 +2081,7 @@ public async Task Test046_Should_Handle_Session_Timeout_During_Entry_Operations( if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2141,7 +2138,7 @@ public async Task Test047_Should_Validate_Workflow_Stage_Permissions() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2211,7 +2208,7 @@ public async Task Test048_Should_Handle_Concurrent_Auth_Context_Loss() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2298,7 +2295,7 @@ public async Task Test049_Should_Block_Entry_Access_With_Malformed_Tokens() { Console.WriteLine($"✅ SDK caught malformed token: {ex.Message}"); } - catch (JsonReaderException ex) + catch (JsonException ex) { // API returned HTML error page instead of JSON for malformed tokens Console.WriteLine($"✅ API blocked malformed token with HTML response: {malformedToken.Substring(0, Math.Min(20, malformedToken.Length))}..."); @@ -2332,7 +2329,7 @@ public async Task Test050_Should_Handle_Publishing_To_Invalid_Environments() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2406,7 +2403,7 @@ public async Task Test051_Should_Fail_With_Invalid_Workflow_Stage_Transitions() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2475,7 +2472,7 @@ public async Task Test052_Should_Handle_Publishing_Validation_Failures() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2536,7 +2533,7 @@ public async Task Test053_Should_Validate_Entry_Publishing_Prerequisites() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2597,7 +2594,7 @@ public async Task Test054_Should_Handle_Unpublishing_Non_Published_Entries() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2658,7 +2655,7 @@ public async Task Test055_Should_Validate_Publishing_Environment_Permissions() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2730,7 +2727,7 @@ public async Task Test056_Should_Handle_Workflow_Action_Conflicts() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2802,7 +2799,7 @@ public async Task Test057_Should_Block_Publishing_Incomplete_Entries() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2867,7 +2864,7 @@ public async Task Test058_Should_Handle_Publishing_Quota_Exceeded() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -2941,7 +2938,7 @@ public async Task Test059_Should_Validate_Publishing_Schedule_Constraints() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3007,7 +3004,7 @@ public async Task Test060_Should_Handle_Localization_To_Invalid_Locales() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3079,7 +3076,7 @@ public async Task Test061_Should_Fail_With_Malformed_Locale_Data() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3167,7 +3164,7 @@ public async Task Test062_Should_Validate_Locale_Fallback_Chains() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3250,7 +3247,7 @@ public async Task Test063_Should_Handle_Import_File_Validation_Errors() // Test if the content would be valid for import try { - var testJson = JObject.Parse(fileContent); + var testJson = JsonNode.Parse(fileContent); Console.WriteLine($"ℹ️ JSON structure validation passed for {Path.GetFileName(filePath)}"); } catch (JsonException ex) @@ -3348,7 +3345,7 @@ public async Task Test065_Should_Handle_Export_Permission_Failures() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3415,14 +3412,14 @@ public async Task Test066_Should_Validate_Import_Schema_Compatibility() // Validate schema compatibility try { - var testJson = JObject.Parse(incompatibleSchema); + var testJson = JsonNode.Parse(incompatibleSchema); // Check for unknown fields var knownFields = new[] { "title", "url", "content_type_uid" }; - var unknownFields = testJson.Properties() - .Where(p => !knownFields.Contains(p.Name)) - .Select(p => p.Name) - .ToList(); + var testObj = testJson as JsonObject; + var unknownFields = testObj == null + ? new List() + : testObj.Where(kvp => !knownFields.Contains(kvp.Key)).Select(kvp => kvp.Key).ToList(); if (unknownFields.Any()) { @@ -3430,7 +3427,8 @@ public async Task Test066_Should_Validate_Import_Schema_Compatibility() } // Check for wrong data types - if (testJson["title"]?.Type != JTokenType.String && testJson["title"] != null) + var titleNode = testJson["title"]; + if (titleNode != null && titleNode.GetValueKind() != JsonValueKind.String) { Console.WriteLine("✅ Invalid data type detected for title field"); } @@ -3474,7 +3472,7 @@ public async Task Test067_Should_Handle_Locale_Deletion_Constraints() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3539,7 +3537,7 @@ public async Task Test068_Should_Block_Unauthorized_Localization_Operations() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3676,7 +3674,7 @@ public async Task Test070_Should_Handle_Concurrent_Entry_Modifications() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3754,7 +3752,7 @@ public async Task Test071_Should_Detect_Entry_Version_Conflicts() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3838,7 +3836,7 @@ public async Task Test072_Should_Handle_Reference_Field_Consistency() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -3862,7 +3860,7 @@ public async Task Test072_Should_Handle_Reference_Field_Consistency() if (mainCreateResponse.IsSuccessStatusCode) { - var responseObj = mainCreateResponse.OpenJObjectResponse(); + var responseObj = mainCreateResponse.OpenJsonObjectResponse(); var mainEntryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(mainEntryUID)) { @@ -3921,7 +3919,7 @@ public async Task Test073_Should_Validate_Entry_State_Integrity() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4002,7 +4000,7 @@ public async Task Test074_Should_Handle_Orphaned_Entry_References() if (parentCreateResponse.IsSuccessStatusCode) { - var parentResponseObj = parentCreateResponse.OpenJObjectResponse(); + var parentResponseObj = parentCreateResponse.OpenJsonObjectResponse(); var parentEntryUID = parentResponseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(parentEntryUID)) { @@ -4019,7 +4017,7 @@ public async Task Test074_Should_Handle_Orphaned_Entry_References() if (childCreateResponse.IsSuccessStatusCode) { - var childResponseObj = childCreateResponse.OpenJObjectResponse(); + var childResponseObj = childCreateResponse.OpenJsonObjectResponse(); var childEntryUID = childResponseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(childEntryUID)) { @@ -4085,7 +4083,7 @@ public async Task Test075_Should_Detect_Content_Type_Schema_Mismatches() if (createResponse.IsSuccessStatusCode) { Console.WriteLine("ℹ️ Schema mismatch was allowed (may have compatible fields)"); - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4128,7 +4126,7 @@ public async Task Test076_Should_Handle_Entry_Locking_During_Updates() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4199,7 +4197,7 @@ public async Task Test077_Should_Validate_Entry_Parent_Child_Relationships() if (parentCreateResponse.IsSuccessStatusCode) { - var parentResponseObj = parentCreateResponse.OpenJObjectResponse(); + var parentResponseObj = parentCreateResponse.OpenJsonObjectResponse(); var parentEntryUID = parentResponseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(parentEntryUID)) { @@ -4221,7 +4219,7 @@ public async Task Test077_Should_Validate_Entry_Parent_Child_Relationships() if (childCreateResponse.IsSuccessStatusCode) { - var childResponseObj = childCreateResponse.OpenJObjectResponse(); + var childResponseObj = childCreateResponse.OpenJsonObjectResponse(); var childEntryUID = childResponseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(childEntryUID)) { @@ -4298,7 +4296,7 @@ public async Task Test078_Should_Handle_Race_Conditions_In_Entry_Creation() if (results[i].IsSuccessStatusCode) { successCount++; - var responseObj = results[i].OpenJObjectResponse(); + var responseObj = results[i].OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4339,7 +4337,7 @@ public async Task Test079_Should_Manage_Entry_Dependency_Validation() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4430,7 +4428,7 @@ public async Task Test080_Should_Handle_Network_Timeout_During_Entry_Operations( if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4512,7 +4510,7 @@ public async Task Test081_Should_Handle_Entry_Operation_Interruption_And_Resume( if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4605,7 +4603,7 @@ public async Task Test082_Should_Handle_API_Rate_Limiting_For_Entry_Operations() if (results[i].IsSuccessStatusCode) { successCount++; - var responseObj = results[i].OpenJObjectResponse(); + var responseObj = results[i].OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4656,7 +4654,7 @@ public async Task Test083_Should_Handle_Service_Unavailable_For_Entry_API() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4753,7 +4751,7 @@ public async Task Test084_Should_Handle_Partial_Entry_Operation_Failures() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4844,7 +4842,7 @@ public async Task Test085_Should_Handle_Connection_Reset_During_Entry_Transfer() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -4976,7 +4974,7 @@ public async Task Test087_Should_Handle_CDN_Unavailability_For_Entry_Assets() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5046,7 +5044,7 @@ public async Task Test088_Should_Handle_Entry_API_Maintenance_Mode() if (createResponse.IsSuccessStatusCode) { - var responseObj = createResponse.OpenJObjectResponse(); + var responseObj = createResponse.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5144,7 +5142,7 @@ public async Task Test089_Should_Handle_Bandwidth_Throttling_For_Entry_Operation if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5221,7 +5219,7 @@ public async Task Test090_Should_Handle_Maximum_Entry_Size_Limits() if (response.IsSuccessStatusCode) { Console.WriteLine($"ℹ️ {test.Name} ({test.Size} chars) was accepted"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5289,7 +5287,7 @@ public async Task Test091_Should_Handle_Maximum_Entry_Count_Per_Content_Type() if (results[i].IsSuccessStatusCode) { successCount++; - var responseObj = results[i].OpenJObjectResponse(); + var responseObj = results[i].OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5347,7 +5345,7 @@ public async Task Test092_Should_Handle_Maximum_Entry_Field_Depth_Limits() if (response.IsSuccessStatusCode) { Console.WriteLine($"✅ Field depth {depthUrl.Split('/').Length} levels accepted"); - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5405,7 +5403,7 @@ public async Task Test093_Should_Handle_Entry_Storage_Quota_Exceeded() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5475,7 +5473,7 @@ public async Task Test094_Should_Handle_Memory_Pressure_During_Entry_Processing( if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5544,7 +5542,7 @@ public async Task Test095_Should_Handle_CPU_Intensive_Entry_Operations() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5609,7 +5607,7 @@ public async Task Test096_Should_Handle_Entry_Operation_Bandwidth_Limits() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5683,7 +5681,7 @@ public async Task Test097_Should_Handle_Concurrent_Entry_Operation_Limits() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5760,7 +5758,7 @@ public async Task Test098_Should_Handle_Entry_API_Request_Quota_Limits() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { @@ -5836,7 +5834,7 @@ public async Task Test099_Should_Handle_Entry_Processing_Queue_Overflow() if (response.IsSuccessStatusCode) { - var responseObj = response.OpenJObjectResponse(); + var responseObj = response.OpenJsonObjectResponse(); var entryUID = responseObj["entry"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(entryUID)) { diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack015_BulkOperationTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack015_BulkOperationTest.cs index 0f43eb1..802c9f5 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack015_BulkOperationTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack015_BulkOperationTest.cs @@ -5,7 +5,6 @@ using System.Net.Http; using System.Threading; using System.Threading.Tasks; -using System.Threading.Tasks; using Contentstack.Management.Core.Exceptions; using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Tests.Helpers; @@ -13,8 +12,6 @@ using Contentstack.Management.Core.Tests.Model; using Contentstack.Management.Core.Abstractions; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; -using Newtonsoft.Json.Linq; namespace Contentstack.Management.Core.Tests.IntegrationTest { @@ -182,7 +179,7 @@ private static void AssertWorkflowCreated() /// private static Stack GetStack() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); return _client.Stack(response.Stack.APIKey); } @@ -212,7 +209,7 @@ public static void ClassCleanup() [TestInitialize] public async Task Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); // Create test environment and release for bulk operations (for new stack) @@ -269,8 +266,8 @@ public void Test000a_Should_Create_Workflow_With_Two_Stages() ContentstackResponse listResponse = _stack.Workflow().FindAll(); if (listResponse.IsSuccessStatusCode) { - var listJson = listResponse.OpenJObjectResponse(); - var existing = (listJson["workflows"] as JArray) ?? (listJson["workflow"] as JArray); + var listJson = listResponse.OpenJsonObjectResponse(); + var existing = (listJson["workflows"] as JsonArray) ?? (listJson["workflow"] as JsonArray); if (existing != null) { foreach (var wf in existing) @@ -278,7 +275,7 @@ public void Test000a_Should_Create_Workflow_With_Two_Stages() if (wf["name"]?.ToString() == workflowName && wf["uid"] != null) { _bulkTestWorkflowUid = wf["uid"].ToString(); - var existingStages = wf["workflow_stages"] as JArray; + var existingStages = wf["workflow_stages"] as JsonArray; if (existingStages != null && existingStages.Count >= 2) { _bulkTestWorkflowStage1Uid = existingStages[0]["uid"]?.ToString(); @@ -344,7 +341,7 @@ public void Test000a_Should_Create_Workflow_With_Two_Stages() }; // Print what we are sending so failures show the exact request JSON - string sentJson = JsonConvert.SerializeObject(new { workflow = workflowModel }, Formatting.Indented); + string sentJson = JsonSerializer.Serialize(new { workflow = workflowModel }, new JsonSerializerOptions { WriteIndented = true }); ContentstackResponse response = _stack.Workflow().Create(workflowModel); string responseBody = null; @@ -354,14 +351,14 @@ public void Test000a_Should_Create_Workflow_With_Two_Stages() AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Workflow create failed: HTTP {(int)response.StatusCode}.\n--- REQUEST BODY ---\n{sentJson}\n--- RESPONSE BODY ---\n{responseBody}", "workflowCreateSuccess"); - var responseJson = JObject.Parse(responseBody ?? "{}"); + var responseJson = JsonNode.Parse(responseBody ?? "{}"); var workflowObj = responseJson["workflow"]; AssertLogger.IsNotNull(workflowObj, "workflowObj"); AssertLogger.IsFalse(string.IsNullOrEmpty(workflowObj["uid"]?.ToString()), "Workflow UID is empty.", "workflowUid"); _bulkTestWorkflowUid = workflowObj["uid"].ToString(); TestOutputLogger.LogContext("WorkflowUid", _bulkTestWorkflowUid); - var stages = workflowObj["workflow_stages"] as JArray; + var stages = workflowObj["workflow_stages"] as JsonArray; AssertLogger.IsNotNull(stages, "workflow_stages"); AssertLogger.IsTrue(stages.Count >= 2, $"Expected at least 2 stages, got {stages.Count}.", "stagesCount"); _bulkTestWorkflowStage1Uid = stages[0]["uid"].ToString(); // New stage 1 @@ -396,8 +393,8 @@ public void Test000b_Should_Create_Publishing_Rule_For_Workflow_Stage2() ContentstackResponse listResponse = _stack.Workflow().PublishRule().FindAll(); if (listResponse.IsSuccessStatusCode) { - var listJson = listResponse.OpenJObjectResponse(); - var rules = (listJson["publishing_rules"] as JArray) ?? (listJson["publishing_rule"] as JArray); + var listJson = listResponse.OpenJsonObjectResponse(); + var rules = (listJson["publishing_rules"] as JsonArray) ?? (listJson["publishing_rule"] as JsonArray); if (rules != null) { foreach (var rule in rules) @@ -429,7 +426,7 @@ public void Test000b_Should_Create_Publishing_Rule_For_Workflow_Stage2() DisableApproval = false }; - string sentJson = JsonConvert.SerializeObject(new { publishing_rule = publishRuleModel }, Formatting.Indented); + string sentJson = JsonSerializer.Serialize(new { publishing_rule = publishRuleModel }, new JsonSerializerOptions { WriteIndented = true }); ContentstackResponse response = _stack.Workflow().PublishRule().Create(publishRuleModel); string responseBody = null; @@ -439,7 +436,7 @@ public void Test000b_Should_Create_Publishing_Rule_For_Workflow_Stage2() AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Publish rule create failed: HTTP {(int)response.StatusCode}.\n--- REQUEST BODY ---\n{sentJson}\n--- RESPONSE BODY ---\n{responseBody}", "publishRuleCreateSuccess"); - var responseJson = JObject.Parse(responseBody ?? "{}"); + var responseJson = JsonNode.Parse(responseBody ?? "{}"); var ruleObj = responseJson["publishing_rule"]; AssertLogger.IsNotNull(ruleObj, "publishing_rule"); AssertLogger.IsFalse(string.IsNullOrEmpty(ruleObj["uid"]?.ToString()), "Publishing rule UID is empty.", "publishRuleUid"); @@ -484,7 +481,7 @@ public async Task Test001_Should_Create_Content_Type_With_Title_Field() // Create the content type ContentstackResponse response = _stack.ContentType().Create(contentModelling); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "createContentTypeResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, "contentTypeCreateSuccess"); @@ -544,7 +541,7 @@ public async Task Test002_Should_Create_Five_Entries() { var entry = new SimpleEntry { Title = title }; ContentstackResponse response = _stack.ContentType(_contentTypeUid).Entry().Create(entry); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "createEntryResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, "entryCreateSuccess"); @@ -601,7 +598,7 @@ public async Task Test003_Should_Perform_Bulk_Publish_Operation() // Perform bulk publish; skipWorkflowStage=true bypasses publish rules enforced by workflow stages ContentstackResponse response = _stack.BulkOperation().Publish(publishDetails, skipWorkflowStage: true, approvals: true); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "bulkPublishResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, "bulkPublishSuccess"); @@ -648,7 +645,7 @@ public async Task Test004_Should_Perform_Bulk_Unpublish_Operation() // Perform bulk unpublish; skipWorkflowStage=true bypasses publish rules enforced by workflow stages ContentstackResponse response = _stack.BulkOperation().Unpublish(unpublishDetails, skipWorkflowStage: true, approvals: true); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "bulkUnpublishResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, "bulkUnpublishSuccess"); @@ -700,7 +697,7 @@ public async Task Test003a_Should_Perform_Bulk_Publish_With_SkipWorkflowStage_An AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Bulk publish failed with status {(int)response.StatusCode} ({response.StatusCode}).", "bulkPublishSuccess"); AssertLogger.AreEqual(HttpStatusCode.OK, response.StatusCode, $"Expected 200 OK, got {(int)response.StatusCode}.", "statusCode"); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseJson, "responseJson"); } catch (Exception ex) @@ -708,7 +705,7 @@ public async Task Test003a_Should_Perform_Bulk_Publish_With_SkipWorkflowStage_An if (ex is ContentstackErrorException cex) { string errorsJson = cex.Errors != null && cex.Errors.Count > 0 - ? JsonConvert.SerializeObject(cex.Errors, Formatting.Indented) + ? JsonSerializer.Serialize(cex.Errors, new JsonSerializerOptions { WriteIndented = true }) : "(none)"; string failMessage = string.Format( "Bulk publish with skipWorkflowStage and approvals failed. HTTP {0} ({1}). ErrorCode: {2}. Message: {3}. Errors: {4}", @@ -765,7 +762,7 @@ public async Task Test004a_Should_Perform_Bulk_UnPublish_With_SkipWorkflowStage_ AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Bulk publish failed with status {(int)response.StatusCode} ({response.StatusCode}).", "bulkUnpublishSuccess"); AssertLogger.AreEqual(HttpStatusCode.OK, response.StatusCode, $"Expected 200 OK, got {(int)response.StatusCode}.", "statusCode"); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseJson, "responseJson"); } catch (Exception ex) @@ -773,7 +770,7 @@ public async Task Test004a_Should_Perform_Bulk_UnPublish_With_SkipWorkflowStage_ if (ex is ContentstackErrorException cex) { string errorsJson = cex.Errors != null && cex.Errors.Count > 0 - ? JsonConvert.SerializeObject(cex.Errors, Formatting.Indented) + ? JsonSerializer.Serialize(cex.Errors, new JsonSerializerOptions { WriteIndented = true }) : "(none)"; string failMessage = string.Format( "Bulk unpublish with skipWorkflowStage and approvals failed. HTTP {0} ({1}). ErrorCode: {2}. Message: {3}. Errors: {4}", @@ -829,7 +826,7 @@ public async Task Test003b_Should_Perform_Bulk_Publish_With_ApiVersion_3_2_With_ AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Bulk publish with api_version 3.2 failed with status {(int)response.StatusCode} ({response.StatusCode}).", "bulkPublishSuccess"); AssertLogger.AreEqual(HttpStatusCode.OK, response.StatusCode, $"Expected 200 OK, got {(int)response.StatusCode}.", "statusCode"); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseJson, "responseJson"); } catch (Exception ex) @@ -873,7 +870,7 @@ public async Task Test004b_Should_Perform_Bulk_UnPublish_With_ApiVersion_3_2_Wit AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Bulk unpublish with api_version 3.2 failed with status {(int)response.StatusCode} ({response.StatusCode}).", "bulkUnpublishSuccess"); AssertLogger.AreEqual(HttpStatusCode.OK, response.StatusCode, $"Expected 200 OK, got {(int)response.StatusCode}.", "statusCode"); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseJson, "responseJson"); } catch (Exception ex) @@ -931,7 +928,7 @@ public async Task Test005_Should_Perform_Bulk_Release_Operations() // Perform bulk release using AddItems in deployment mode ContentstackResponse releaseResponse = _stack.BulkOperation().AddItems(releaseData, "2.0"); - var releaseResponseJson = releaseResponse.OpenJObjectResponse(); + var releaseResponseJson = releaseResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(releaseResponse, "releaseResponse"); AssertLogger.IsTrue(releaseResponse.IsSuccessStatusCode, "releaseAddItemsSuccess"); @@ -987,7 +984,7 @@ public async Task Test006_Should_Update_Items_In_Release() }; ContentstackResponse bulkUpdateResponse = _stack.BulkOperation().UpdateItems(releaseData, "2.0"); - var bulkUpdateResponseJson = bulkUpdateResponse.OpenJObjectResponse(); + var bulkUpdateResponseJson = bulkUpdateResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(bulkUpdateResponse, "bulkUpdateResponse"); AssertLogger.IsTrue(bulkUpdateResponse.IsSuccessStatusCode, "bulkUpdateSuccess"); @@ -1071,7 +1068,7 @@ public async Task Test008_Should_Perform_Bulk_Workflow_Operations() }; ContentstackResponse response = _stack.BulkOperation().Update(workflowUpdateBody); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(response, "bulkWorkflowResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, "bulkWorkflowSuccess"); @@ -1288,7 +1285,7 @@ public void Test016_BulkOperations_Should_Fail_When_Not_Logged_In() { // Create unauthenticated client var unauthenticatedClient = new ContentstackClient(); - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); var unauthenticatedStack = unauthenticatedClient.Stack(response.Stack.APIKey); var publishDetails = new BulkPublishDetails @@ -1338,7 +1335,7 @@ public void Test017_BulkOperations_Should_Fail_With_Invalid_Auth_Token() // Note: LoginAsync requires ICredentials, not string // invalidClient.LoginAsync("invalid_authtoken_12345").Wait(); - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); var invalidStack = invalidClient.Stack(response.Stack.APIKey); var publishDetails = new BulkPublishDetails @@ -2971,7 +2968,7 @@ public async Task Test053_BulkOperations_Should_Handle_Job_Creation_Failures() var response = await _stack.BulkOperation().AddItemsAsync(problematicData); if (response.IsSuccessStatusCode) { - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (responseJson["job_id"] != null) { string jobId = responseJson["job_id"].ToString(); @@ -2983,7 +2980,7 @@ public async Task Test053_BulkOperations_Should_Handle_Job_Creation_Failures() try { var jobStatusResponse = await _stack.BulkOperation().JobStatusAsync(jobId); - var jobJson = jobStatusResponse.OpenJObjectResponse(); + var jobJson = jobStatusResponse.OpenJsonObjectResponse(); // Look for failure indicators in job status if (jobJson["status"]?.ToString() == "failed" || @@ -3113,7 +3110,7 @@ public async Task Test055_BulkOperations_Should_Handle_Concurrent_Job_Requests() var result = results[i]; if (result.IsSuccessStatusCode) { - var resultJson = result.OpenJObjectResponse(); + var resultJson = result.OpenJsonObjectResponse(); if (resultJson["job_id"] != null) { Console.WriteLine($"[Test055] Concurrent job {i + 1} created successfully: {resultJson["job_id"]}"); @@ -3181,7 +3178,7 @@ public async Task Test056_BulkOperations_Should_Handle_Job_Status_Polling_Errors var response = await _stack.BulkOperation().UpdateAsync(workflowBody); if (response.IsSuccessStatusCode) { - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (responseJson["job_id"] != null) { string jobId = responseJson["job_id"].ToString(); @@ -3603,7 +3600,7 @@ private async Task CheckBulkJobStatus(string jobId, string bulkVersion = null) try { ContentstackResponse statusResponse = await _stack.BulkOperation().JobStatusAsync(jobId, bulkVersion); - var statusJson = statusResponse.OpenJObjectResponse(); + var statusJson = statusResponse.OpenJsonObjectResponse(); AssertLogger.IsNotNull(statusResponse, "jobStatusResponse"); AssertLogger.IsTrue(statusResponse.IsSuccessStatusCode, "jobStatusSuccess"); @@ -3633,7 +3630,7 @@ private async Task CreateTestEnvironment() }; ContentstackResponse response = _stack.Environment().Create(environmentModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["environment"] != null) { @@ -3660,7 +3657,7 @@ private async Task CreateTestRelease() }; ContentstackResponse response = _stack.Release().Create(releaseModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["release"] != null) { @@ -3698,11 +3695,11 @@ private async Task> GetAvailableEnvironments() try { ContentstackResponse response = _stack.Environment().Query().Find(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["environments"] != null) { - var environments = responseJson["environments"] as JArray; + var environments = responseJson["environments"] as JsonArray; if (environments != null && environments.Count > 0) { var environmentUids = new List(); @@ -3779,7 +3776,7 @@ private async Task EnsureBulkTestContentTypeAndEntriesAsync() { var entry = new SimpleEntry { Title = "Bulk test entry" }; ContentstackResponse createResponse = _stack.ContentType(_contentTypeUid).Entry().Create(entry); - var responseJson = createResponse.OpenJObjectResponse(); + var responseJson = createResponse.OpenJsonObjectResponse(); if (createResponse.IsSuccessStatusCode && responseJson["entry"] != null && responseJson["entry"]["uid"] != null) { _createdEntries.Add(new EntryInfo @@ -3805,10 +3802,10 @@ private static List GetAvailableEnvironments(Stack stack) try { ContentstackResponse response = stack.Environment().Query().Find(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["environments"] != null) { - var environments = responseJson["environments"] as JArray; + var environments = responseJson["environments"] as JsonArray; if (environments != null && environments.Count > 0) { var uids = new List(); @@ -3833,10 +3830,10 @@ private static async Task> GetAvailableEnvironmentsAsync(Stack stac try { ContentstackResponse response = stack.Environment().Query().Find(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["environments"] != null) { - var environments = responseJson["environments"] as JArray; + var environments = responseJson["environments"] as JsonArray; if (environments != null && environments.Count > 0) { var uids = new List(); @@ -3881,7 +3878,7 @@ private static void EnsureBulkTestEnvironment(Stack stack) }; ContentstackResponse response = stack.Environment().Create(environmentModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["environment"]?["uid"] != null) _bulkTestEnvironmentUid = responseJson["environment"]["uid"].ToString(); } @@ -3916,7 +3913,7 @@ private static async Task EnsureBulkTestEnvironmentAsync(Stack stack) }; ContentstackResponse response = stack.Environment().Create(environmentModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["environment"]?["uid"] != null) _bulkTestEnvironmentUid = responseJson["environment"]["uid"].ToString(); } @@ -3945,8 +3942,8 @@ private static async Task EnsureBulkTestWorkflowAndPublishingRuleAsync(Stack sta ContentstackResponse listResponse = stack.Workflow().FindAll(); if (listResponse.IsSuccessStatusCode) { - var listJson = listResponse.OpenJObjectResponse(); - var existing = (listJson["workflows"] as JArray) ?? (listJson["workflow"] as JArray); + var listJson = listResponse.OpenJsonObjectResponse(); + var existing = (listJson["workflows"] as JsonArray) ?? (listJson["workflow"] as JsonArray); if (existing != null) { foreach (var wf in existing) @@ -3954,7 +3951,7 @@ private static async Task EnsureBulkTestWorkflowAndPublishingRuleAsync(Stack sta if (wf["name"]?.ToString() == workflowName && wf["uid"] != null) { _bulkTestWorkflowUid = wf["uid"].ToString(); - var existingStages = wf["workflow_stages"] as JArray; + var existingStages = wf["workflow_stages"] as JsonArray; if (existingStages != null && existingStages.Count >= 2) { _bulkTestWorkflowStage1Uid = existingStages[0]["uid"]?.ToString(); @@ -4029,7 +4026,7 @@ private static async Task EnsureBulkTestWorkflowAndPublishingRuleAsync(Stack sta return; } - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); var workflowObj = workflowJson["workflow"]; if (workflowObj == null) { @@ -4040,7 +4037,7 @@ private static async Task EnsureBulkTestWorkflowAndPublishingRuleAsync(Stack sta } _bulkTestWorkflowUid = workflowObj["uid"]?.ToString(); - var stages = workflowObj["workflow_stages"] as JArray; + var stages = workflowObj["workflow_stages"] as JsonArray; if (stages != null && stages.Count >= 2) { _bulkTestWorkflowStage1Uid = stages[0]?["uid"]?.ToString(); @@ -4061,8 +4058,8 @@ private static async Task EnsureBulkTestWorkflowAndPublishingRuleAsync(Stack sta ContentstackResponse ruleListResponse = stack.Workflow().PublishRule().FindAll(); if (ruleListResponse.IsSuccessStatusCode) { - var ruleListJson = ruleListResponse.OpenJObjectResponse(); - var rules = (ruleListJson["publishing_rules"] as JArray) ?? (ruleListJson["publishing_rule"] as JArray); + var ruleListJson = ruleListResponse.OpenJsonObjectResponse(); + var rules = (ruleListJson["publishing_rules"] as JsonArray) ?? (ruleListJson["publishing_rule"] as JsonArray); if (rules != null) { foreach (var rule in rules) @@ -4103,7 +4100,7 @@ private static async Task EnsureBulkTestWorkflowAndPublishingRuleAsync(Stack sta return; } - var ruleJson = ruleResponse.OpenJObjectResponse(); + var ruleJson = ruleResponse.OpenJsonObjectResponse(); _bulkTestPublishRuleUid = ruleJson["publishing_rule"]?["uid"]?.ToString(); } catch (ContentstackErrorException ex) @@ -4177,7 +4174,7 @@ private async Task AssignEntriesToWorkflowStagesAsync(List entries) ContentstackResponse r = _stack.BulkOperation().Update(body); if (r.IsSuccessStatusCode) { - var j = r.OpenJObjectResponse(); + var j = r.OpenJsonObjectResponse(); if (j?["job_id"] != null) { await Task.Delay(2000); await CheckBulkJobStatus(j["job_id"].ToString()); } } } @@ -4191,11 +4188,11 @@ private async Task> FetchExistingEntries() { // Query entries from the content type ContentstackResponse response = _stack.ContentType(_contentTypeUid).Entry().Query().Find(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["entries"] != null) { - var entries = responseJson["entries"] as JArray; + var entries = responseJson["entries"] as JsonArray; if (entries != null && entries.Count > 0) { var entryList = new List(); @@ -4248,11 +4245,11 @@ private async Task> GetAvailableReleases() try { ContentstackResponse response = _stack.Release().Query().Find(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["releases"] != null) { - var releases = responseJson["releases"] as JArray; + var releases = responseJson["releases"] as JsonArray; if (releases != null && releases.Count > 0) { var releaseUids = new List(); @@ -4304,11 +4301,11 @@ private async Task FetchAvailableRelease() // Query for available releases ContentstackResponse response = _stack.Release().Query().Find(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); if (response.IsSuccessStatusCode && responseJson["releases"] != null) { - var releases = responseJson["releases"] as JArray; + var releases = responseJson["releases"] as JsonArray; if (releases != null && releases.Count > 0) { // Get the first available release @@ -4331,10 +4328,10 @@ private async Task FetchAvailableRelease() public class SimpleEntry : IEntry { - [JsonProperty(propertyName: "title")] + [JsonPropertyName("title")] public string Title { get; set; } - [JsonProperty(propertyName: "_variant")] + [JsonPropertyName("_variant")] public object Variant { get; set; } } diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack016_DeliveryTokenTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack016_DeliveryTokenTest.cs index 21639eb..4564d37 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack016_DeliveryTokenTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack016_DeliveryTokenTest.cs @@ -7,11 +7,9 @@ using Contentstack.Management.Core.Tests.Model; using Contentstack.Management.Core.Queryable; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json.Linq; using System.Security.Cryptography; using System.Net; using Contentstack.Management.Core.Exceptions; -using Newtonsoft.Json; using System.Threading; using System.Linq; @@ -52,7 +50,7 @@ public async Task Initialize() { try { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); // Cleanup existing test resources first @@ -107,10 +105,10 @@ public async Task Test001_Should_Create_Delivery_Token() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Create delivery token failed", "CreateDeliveryTokenSuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["token"], "Response should contain token object"); - var tokenData = responseObject["token"] as JObject; + var tokenData = responseObject["token"] as JsonObject; AssertLogger.IsNotNull(tokenData["uid"], "Token should have UID"); AssertLogger.AreEqual(_testTokenModel.Name, tokenData["name"]?.ToString(), "Token name should match", "TokenName"); AssertLogger.AreEqual(_testTokenModel.Description, tokenData["description"]?.ToString(), "Token description should match", "TokenDescription"); @@ -165,10 +163,10 @@ public async Task Test002_Should_Create_Delivery_Token_Async() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Async create delivery token failed", "AsyncCreateSuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["token"], "Response should contain token object"); - var tokenData = responseObject["token"] as JObject; + var tokenData = responseObject["token"] as JsonObject; AssertLogger.IsNotNull(tokenData["uid"], "Token should have UID"); AssertLogger.AreEqual(asyncTokenModel.Name, tokenData["name"]?.ToString(), "Token name should match", "AsyncTokenName"); @@ -204,10 +202,10 @@ public async Task Test003_Should_Fetch_Delivery_Token() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Fetch delivery token failed", "FetchSuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["token"], "Response should contain token object"); - var tokenData = responseObject["token"] as JObject; + var tokenData = responseObject["token"] as JsonObject; AssertLogger.AreEqual(_deliveryTokenUid, tokenData["uid"]?.ToString(), "Token UID should match", "TokenUid"); AssertLogger.AreEqual(_testTokenModel.Name, tokenData["name"]?.ToString(), "Token name should match", "TokenName"); AssertLogger.IsNotNull(tokenData["token"], "Token should have access token"); @@ -236,10 +234,10 @@ public async Task Test004_Should_Fetch_Delivery_Token_Async() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Async fetch delivery token failed", "AsyncFetchSuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["token"], "Response should contain token object"); - var tokenData = responseObject["token"] as JObject; + var tokenData = responseObject["token"] as JsonObject; AssertLogger.AreEqual(_deliveryTokenUid, tokenData["uid"]?.ToString(), "Token UID should match", "TokenUid"); AssertLogger.IsNotNull(tokenData["token"], "Token should have access token"); } @@ -293,10 +291,10 @@ public async Task Test005_Should_Update_Delivery_Token() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Update delivery token failed", "UpdateSuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["token"], "Response should contain token object"); - var tokenData = responseObject["token"] as JObject; + var tokenData = responseObject["token"] as JsonObject; AssertLogger.AreEqual(_deliveryTokenUid, tokenData["uid"]?.ToString(), "Token UID should match", "TokenUid"); AssertLogger.AreEqual(updateModel.Name, tokenData["name"]?.ToString(), "Updated token name should match", "UpdatedTokenName"); AssertLogger.AreEqual(updateModel.Description, tokenData["description"]?.ToString(), "Updated token description should match", "UpdatedTokenDescription"); @@ -351,10 +349,10 @@ public async Task Test006_Should_Update_Delivery_Token_Async() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Async update delivery token failed", "AsyncUpdateSuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["token"], "Response should contain token object"); - var tokenData = responseObject["token"] as JObject; + var tokenData = responseObject["token"] as JsonObject; AssertLogger.AreEqual(_deliveryTokenUid, tokenData["uid"]?.ToString(), "Token UID should match", "TokenUid"); AssertLogger.AreEqual(updateModel.Name, tokenData["name"]?.ToString(), "Updated token name should match", "UpdatedTokenName"); @@ -382,10 +380,10 @@ public async Task Test007_Should_Query_All_Delivery_Tokens() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Query delivery tokens failed", "QuerySuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["tokens"], "Response should contain tokens array"); - var tokens = responseObject["tokens"] as JArray; + var tokens = responseObject["tokens"] as JsonArray; AssertLogger.IsTrue(tokens.Count > 0, "Should have at least one delivery token", "TokensCountGreaterThanZero"); bool foundTestToken = false; @@ -428,10 +426,10 @@ public async Task Test008_Should_Query_Delivery_Tokens_With_Parameters() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Query delivery tokens with parameters failed", "QueryWithParamsSuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["tokens"], "Response should contain tokens array"); - var tokens = responseObject["tokens"] as JArray; + var tokens = responseObject["tokens"] as JsonArray; AssertLogger.IsTrue(tokens.Count <= 5, "Should respect limit parameter", "RespectLimitParam"); } @@ -483,14 +481,14 @@ public async Task Test009_Should_Create_Token_With_Multiple_Environments() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Create multi-environment delivery token failed", "MultiEnvCreateSuccess"); - var responseObject = response.OpenJObjectResponse(); - var tokenData = responseObject["token"] as JObject; + var responseObject = response.OpenJsonObjectResponse(); + var tokenData = responseObject["token"] as JsonObject; AssertLogger.IsNotNull(tokenData["uid"], "Token should have UID"); string multiEnvTokenUid = tokenData["uid"]?.ToString(); TestOutputLogger.LogContext("MultiEnvTokenUid", multiEnvTokenUid ?? ""); - var scope = tokenData["scope"] as JArray; + var scope = tokenData["scope"] as JsonArray; AssertLogger.IsNotNull(scope, "Token should have scope"); AssertLogger.IsTrue(scope.Count > 0, "Token should have at least one scope", "ScopeCount"); @@ -546,15 +544,15 @@ public async Task Test011_Should_Create_Token_With_Complex_Scope() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Create complex scope delivery token failed", "ComplexScopeCreateSuccess"); - var responseObject = response.OpenJObjectResponse(); - var tokenData = responseObject["token"] as JObject; + var responseObject = response.OpenJsonObjectResponse(); + var tokenData = responseObject["token"] as JsonObject; AssertLogger.IsNotNull(tokenData["uid"], "Token should have UID"); string complexScopeTokenUid = tokenData["uid"]?.ToString(); TestOutputLogger.LogContext("ComplexScopeTokenUid", complexScopeTokenUid ?? ""); // Verify multiple scopes - var scope = tokenData["scope"] as JArray; + var scope = tokenData["scope"] as JsonArray; AssertLogger.IsNotNull(scope, "Token should have scope"); AssertLogger.IsTrue(scope.Count >= 2, "Token should have multiple scopes", "ScopeCountMultiple"); @@ -610,13 +608,13 @@ public async Task Test012_Should_Create_Token_With_UI_Structure() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Create UI structure delivery token failed", "UIStructureCreateSuccess"); - var responseObject = response.OpenJObjectResponse(); - var tokenData = responseObject["token"] as JObject; + var responseObject = response.OpenJsonObjectResponse(); + var tokenData = responseObject["token"] as JsonObject; AssertLogger.IsNotNull(tokenData["uid"], "Token should have UID"); AssertLogger.AreEqual(uiStructureTokenModel.Name, tokenData["name"]?.ToString(), "Token name should match", "UITokenName"); // Verify the scope structure matches UI format - var scope = tokenData["scope"] as JArray; + var scope = tokenData["scope"] as JsonArray; AssertLogger.IsNotNull(scope, "Token should have scope"); AssertLogger.IsTrue(scope.Count == 2, "Token should have 2 scope modules (environment and branch)", "UIScopeCount"); @@ -654,10 +652,10 @@ public async Task Test015_Should_Query_Delivery_Tokens_Async() AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Async query delivery tokens failed: {response.OpenResponse()}", "AsyncQuerySuccess"); - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject["tokens"], "Response should contain tokens array"); - var tokens = responseObject["tokens"] as JArray; + var tokens = responseObject["tokens"] as JsonArray; AssertLogger.IsTrue(tokens.Count > 0, "Should have at least one delivery token", "AsyncTokensCount"); bool foundTestToken = false; @@ -717,8 +715,8 @@ public async Task Test016_Should_Create_Token_With_Empty_Description() AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Create token with empty description failed: {response.OpenResponse()}", "EmptyDescCreateSuccess"); - var responseObject = response.OpenJObjectResponse(); - var tokenData = responseObject["token"] as JObject; + var responseObject = response.OpenJsonObjectResponse(); + var tokenData = responseObject["token"] as JsonObject; AssertLogger.IsNotNull(tokenData["uid"], "Token should have UID"); AssertLogger.AreEqual(emptyDescTokenModel.Name, tokenData["name"]?.ToString(), "Token name should match", "EmptyDescTokenName"); @@ -947,8 +945,8 @@ public void Test023_Should_Accept_Create_With_Whitespace_Only_Name() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Should accept token with whitespace name"); // Get token UID for cleanup - var responseObject = response.OpenJObjectResponse(); - var tokenData = responseObject["token"] as JObject; + var responseObject = response.OpenJsonObjectResponse(); + var tokenData = responseObject["token"] as JsonObject; string createdTokenUid = tokenData["uid"]?.ToString(); // Verify name contains whitespace @@ -999,8 +997,8 @@ public void Test025_Should_Accept_Create_With_Invalid_Name_Characters() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Should accept token with special characters"); // Get token UID for cleanup - var responseObject = response.OpenJObjectResponse(); - var tokenData = responseObject["token"] as JObject; + var responseObject = response.OpenJsonObjectResponse(); + var tokenData = responseObject["token"] as JsonObject; string createdTokenUid = tokenData["uid"]?.ToString(); // Verify name contains special characters @@ -1690,7 +1688,7 @@ public void Test070_Should_Accept_Query_With_Negative_Limit() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Should accept query with negative limit"); // Server should return results even with negative limit - var tokens = response.OpenJObjectResponse()["tokens"]; + var tokens = response.OpenJsonObjectResponse()["tokens"]; AssertLogger.IsNotNull(tokens, "Should return tokens array"); } catch (ArgumentException ex) @@ -1735,7 +1733,7 @@ public void Test072_Should_Accept_Query_With_Excessive_Limit() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Should accept query with large limit"); // Server should return results even with excessive limit - var tokens = response.OpenJObjectResponse()["tokens"]; + var tokens = response.OpenJsonObjectResponse()["tokens"]; AssertLogger.IsNotNull(tokens, "Should return tokens array"); } catch (ArgumentException ex) @@ -1789,7 +1787,7 @@ public async Task Test074_Should_Accept_Query_With_Invalid_Parameters_Async() AssertLogger.IsTrue(response.IsSuccessStatusCode, "Should accept async query with negative limit"); // Server should return results even with negative limit - var tokens = response.OpenJObjectResponse()["tokens"]; + var tokens = response.OpenJsonObjectResponse()["tokens"]; AssertLogger.IsNotNull(tokens, "Should return tokens array"); } catch (ArgumentException ex) @@ -1912,8 +1910,8 @@ public async Task Test082_Should_Handle_Permission_Scenarios_Async() if (createResponse.IsSuccessStatusCode) { // Clean up the test token if created - var responseObject = createResponse.OpenJObjectResponse(); - var tokenData = responseObject["token"] as JObject; + var responseObject = createResponse.OpenJsonObjectResponse(); + var tokenData = responseObject["token"] as JsonObject; string tokenUid = tokenData["uid"]?.ToString(); if (!string.IsNullOrEmpty(tokenUid)) @@ -2004,7 +2002,7 @@ public async Task Test091_Should_Handle_Large_Response_Data() if (response.IsSuccessStatusCode) { - var responseObject = response.OpenJObjectResponse(); + var responseObject = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(responseObject, "Response should be parseable even if large"); } } @@ -2176,7 +2174,7 @@ public async Task Cleanup() var tokensResponse = _stack.DeliveryToken().Query().Find(); if (tokensResponse.IsSuccessStatusCode) { - var tokens = tokensResponse.OpenJObjectResponse()["tokens"] as JArray; + var tokens = tokensResponse.OpenJsonObjectResponse()["tokens"] as JsonArray; if (tokens?.Count > 0) { foreach (var token in tokens) @@ -2229,7 +2227,7 @@ private async Task CleanupTestResources() var tokensResponse = _stack.DeliveryToken().Query().Find(); if (tokensResponse.IsSuccessStatusCode) { - var tokens = tokensResponse.OpenJObjectResponse()["tokens"] as JArray; + var tokens = tokensResponse.OpenJsonObjectResponse()["tokens"] as JsonArray; if (tokens?.Count > 0) { foreach (var token in tokens) @@ -2265,7 +2263,7 @@ private async Task CleanupTestResources() var environmentsResponse = _stack.Environment().Query().Find(); if (environmentsResponse.IsSuccessStatusCode) { - var environments = environmentsResponse.OpenJObjectResponse()["environments"] as JArray; + var environments = environmentsResponse.OpenJsonObjectResponse()["environments"] as JsonArray; if (environments?.Count > 0) { foreach (var env in environments) @@ -2592,8 +2590,8 @@ private async Task CreateTemporaryTokenForTesting(string baseName) if (response.IsSuccessStatusCode) { - var responseObject = response.OpenJObjectResponse(); - var tokenData = responseObject["token"] as JObject; + var responseObject = response.OpenJsonObjectResponse(); + var tokenData = responseObject["token"] as JsonObject; return tokenData["uid"]?.ToString(); } } @@ -2630,7 +2628,7 @@ private async Task CreateTestEnvironment(string environmentUid = null) response = _stack.Environment().Query().Find(); if (response.IsSuccessStatusCode) { - var environments = response.OpenJObjectResponse()["environments"] as JArray; + var environments = response.OpenJsonObjectResponse()["environments"] as JsonArray; if (environments?.Count > 0) { Console.WriteLine($"Test environment {envUid} already exists"); @@ -2664,7 +2662,7 @@ private async Task CleanupTestEnvironment(string environmentUid = null) if (queryResponse.IsSuccessStatusCode) { - var environments = queryResponse.OpenJObjectResponse()["environments"] as JArray; + var environments = queryResponse.OpenJsonObjectResponse()["environments"] as JsonArray; if (environments?.Count > 0) { // Find the environment with matching name diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack017_TaxonomyTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack017_TaxonomyTest.cs index c9c7a98..a818734 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack017_TaxonomyTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack017_TaxonomyTest.cs @@ -16,8 +16,6 @@ using Contentstack.Management.Core.Tests.Helpers; using Contentstack.Management.Core.Tests.Model; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json.Linq; - namespace Contentstack.Management.Core.Tests.IntegrationTest { [TestClass] @@ -46,7 +44,7 @@ public static void ClassInitialize(TestContext context) [TestInitialize] public void Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); if (_taxonomyUid == null) _taxonomyUid = "taxonomy_integration_test_" + Guid.NewGuid().ToString("N").Substring(0, 8); @@ -195,7 +193,7 @@ public void Test009_Should_Get_Taxonomy_Locales() TestOutputLogger.LogContext("TaxonomyUid", _taxonomyUid ?? ""); ContentstackResponse response = _stack.Taxonomy(_taxonomyUid).Locales(); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Locales failed: {response.OpenResponse()}", "LocalesSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj["taxonomies"], "Taxonomies in locales response"); } @@ -207,7 +205,7 @@ public async Task Test010_Should_Get_Taxonomy_Locales_Async() TestOutputLogger.LogContext("TaxonomyUid", _taxonomyUid ?? ""); ContentstackResponse response = await _stack.Taxonomy(_taxonomyUid).LocalesAsync(); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"LocalesAsync failed: {response.OpenResponse()}", "LocalesAsyncSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj["taxonomies"], "Taxonomies in locales response"); } @@ -219,8 +217,8 @@ public void Test011_Should_Localize_Taxonomy() _weCreatedTestLocale = false; ContentstackResponse localesResponse = _stack.Locale().Query().Find(); AssertLogger.IsTrue(localesResponse.IsSuccessStatusCode, $"Query locales failed: {localesResponse.OpenResponse()}", "QueryLocalesSuccess"); - var jobj = localesResponse.OpenJObjectResponse(); - var localesArray = jobj["locales"] as JArray ?? jobj["items"] as JArray; + var jobj = localesResponse.OpenJsonObjectResponse(); + var localesArray = jobj["locales"] as JsonArray ?? jobj["items"] as JsonArray; if (localesArray == null || localesArray.Count == 0) { AssertLogger.Inconclusive("Stack has no locales; skipping taxonomy localize tests."); @@ -537,7 +535,7 @@ public void Test024_Should_Get_Term_Ancestors() TestOutputLogger.LogContext("ChildTermUid", _childTermUid ?? ""); ContentstackResponse response = _stack.Taxonomy(_taxonomyUid).Terms(_childTermUid).Ancestors(); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Ancestors failed: {response.OpenResponse()}", "AncestorsSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj, "Ancestors response"); } @@ -550,7 +548,7 @@ public async Task Test025_Should_Get_Term_Ancestors_Async() TestOutputLogger.LogContext("ChildTermUid", _childTermUid ?? ""); ContentstackResponse response = await _stack.Taxonomy(_taxonomyUid).Terms(_childTermUid).AncestorsAsync(); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"AncestorsAsync failed: {response.OpenResponse()}", "AncestorsAsyncSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj, "Ancestors async response"); } @@ -563,7 +561,7 @@ public void Test026_Should_Get_Term_Descendants() TestOutputLogger.LogContext("RootTermUid", _rootTermUid ?? ""); ContentstackResponse response = _stack.Taxonomy(_taxonomyUid).Terms(_rootTermUid).Descendants(); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Descendants failed: {response.OpenResponse()}", "DescendantsSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj, "Descendants response"); } @@ -576,7 +574,7 @@ public async Task Test027_Should_Get_Term_Descendants_Async() TestOutputLogger.LogContext("RootTermUid", _rootTermUid ?? ""); ContentstackResponse response = await _stack.Taxonomy(_taxonomyUid).Terms(_rootTermUid).DescendantsAsync(); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"DescendantsAsync failed: {response.OpenResponse()}", "DescendantsAsyncSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj, "Descendants async response"); } @@ -589,7 +587,7 @@ public void Test028_Should_Get_Term_Locales() TestOutputLogger.LogContext("RootTermUid", _rootTermUid ?? ""); ContentstackResponse response = _stack.Taxonomy(_taxonomyUid).Terms(_rootTermUid).Locales(); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Term Locales failed: {response.OpenResponse()}", "TermLocalesSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj["terms"], "Terms in locales response"); } @@ -602,7 +600,7 @@ public async Task Test029_Should_Get_Term_Locales_Async() TestOutputLogger.LogContext("RootTermUid", _rootTermUid ?? ""); ContentstackResponse response = await _stack.Taxonomy(_taxonomyUid).Terms(_rootTermUid).LocalesAsync(); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Term LocalesAsync failed: {response.OpenResponse()}", "TermLocalesAsyncSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj["terms"], "Terms in locales async response"); } @@ -710,7 +708,7 @@ public void Test034_Should_Search_Terms() TestOutputLogger.LogContext("TaxonomyUid", _taxonomyUid ?? ""); ContentstackResponse response = _stack.Taxonomy(_taxonomyUid).Terms().Search("Root"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Search terms failed: {response.OpenResponse()}", "SearchTermsSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj["terms"] ?? jobj["items"], "Terms or items in search response"); } @@ -722,7 +720,7 @@ public async Task Test035_Should_Search_Terms_Async() TestOutputLogger.LogContext("TaxonomyUid", _taxonomyUid ?? ""); ContentstackResponse response = await _stack.Taxonomy(_taxonomyUid).Terms().SearchAsync("Root"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"SearchAsync terms failed: {response.OpenResponse()}", "SearchAsyncTermsSuccess"); - var jobj = response.OpenJObjectResponse(); + var jobj = response.OpenJsonObjectResponse(); AssertLogger.IsNotNull(jobj["terms"] ?? jobj["items"], "Terms or items in search async response"); } @@ -6465,7 +6463,7 @@ public void Test279_Should_Handle_Extreme_Boundary_Combinations() private static Stack GetStack() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); return _client.Stack(response.Stack.APIKey); } diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack018_EnvironmentTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack018_EnvironmentTest.cs index 2a8dfdd..b2cf03a 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack018_EnvironmentTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack018_EnvironmentTest.cs @@ -8,7 +8,7 @@ using Contentstack.Management.Core.Tests.Helpers; using Contentstack.Management.Core.Tests.Model; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json.Linq; +using System.Text.Json.Nodes; namespace Contentstack.Management.Core.Tests.IntegrationTest { @@ -40,7 +40,7 @@ public static void ClassCleanup() [TestInitialize] public void Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); } @@ -63,7 +63,7 @@ private static EnvironmentModel BuildModel(string uniqueName) private static string ParseEnvironmentName(ContentstackResponse response) { - var jo = response.OpenJObjectResponse(); + var jo = response.OpenJsonObjectResponse(); return jo?["environment"]?["name"]?.ToString(); } @@ -84,7 +84,7 @@ private void SafeDelete(string environmentName) } } - private static bool EnvironmentsArrayContainsName(JArray environments, string name) + private static bool EnvironmentsArrayContainsName(JsonArray environments, string name) { if (environments == null || string.IsNullOrEmpty(name)) { @@ -112,7 +112,7 @@ public void Test001_Should_Create_Environment_Sync() AssertLogger.IsNotNull(environmentName, "environment name"); AssertLogger.AreEqual(name, environmentName, "Parsed name should match request", "ParsedEnvironmentName"); - var jo = response.OpenJObjectResponse(); + var jo = response.OpenJsonObjectResponse(); AssertLogger.AreEqual(name, jo["environment"]?["name"]?.ToString(), "Response name should match", "EnvironmentName"); } finally @@ -135,12 +135,12 @@ public void Test002_Should_Fetch_Environment_Sync() AssertLogger.IsNotNull(environmentName, "name after create"); AssertLogger.AreEqual(name, environmentName, "Parsed name should match create request", "CreateNameMatch"); - string expectedUid = createResponse.OpenJObjectResponse()?["environment"]?["uid"]?.ToString(); + string expectedUid = createResponse.OpenJsonObjectResponse()?["environment"]?["uid"]?.ToString(); ContentstackResponse fetchResponse = _stack.Environment(name).Fetch(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "Fetch should succeed", "FetchSyncSuccess"); - var env = fetchResponse.OpenJObjectResponse()?["environment"]; + var env = fetchResponse.OpenJsonObjectResponse()?["environment"]; AssertLogger.AreEqual(name, env?["name"]?.ToString(), "Fetched name should match", "FetchedName"); AssertLogger.AreEqual(expectedUid, env?["uid"]?.ToString(), "Fetched uid should match create response", "FetchedUid"); } @@ -166,7 +166,7 @@ public void Test003_Should_Query_Environments_Sync() ContentstackResponse queryResponse = _stack.Environment().Query().Find(); AssertLogger.IsTrue(queryResponse.IsSuccessStatusCode, "Query Find should succeed", "QueryFindSuccess"); - var environments = queryResponse.OpenJObjectResponse()?["environments"] as JArray; + var environments = queryResponse.OpenJsonObjectResponse()?["environments"] as JsonArray; AssertLogger.IsNotNull(environments, "environments array"); AssertLogger.IsTrue( EnvironmentsArrayContainsName(environments, name), @@ -202,7 +202,7 @@ public void Test004_Should_Update_Environment_Sync() ContentstackResponse fetchResponse = _stack.Environment(updatedName).Fetch(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "Fetch after update should succeed", "FetchAfterUpdate"); - var env = fetchResponse.OpenJObjectResponse()?["environment"]; + var env = fetchResponse.OpenJsonObjectResponse()?["environment"]; AssertLogger.AreEqual(updatedName, env?["name"]?.ToString(), "Name should reflect update", "UpdatedName"); } finally @@ -261,7 +261,7 @@ public async Task Test006_Should_Create_Environment_Async() AssertLogger.IsNotNull(environmentName, "environment name"); AssertLogger.AreEqual(name, environmentName, "Parsed name should match request", "ParsedEnvironmentName"); - var jo = response.OpenJObjectResponse(); + var jo = response.OpenJsonObjectResponse(); AssertLogger.AreEqual(name, jo["environment"]?["name"]?.ToString(), "Response name should match", "EnvironmentName"); } finally @@ -284,12 +284,12 @@ public async Task Test007_Should_Fetch_Environment_Async() AssertLogger.IsNotNull(environmentName, "name after create"); AssertLogger.AreEqual(name, environmentName, "Parsed name should match create request", "CreateNameMatch"); - string expectedUid = createResponse.OpenJObjectResponse()?["environment"]?["uid"]?.ToString(); + string expectedUid = createResponse.OpenJsonObjectResponse()?["environment"]?["uid"]?.ToString(); ContentstackResponse fetchResponse = await _stack.Environment(name).FetchAsync(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "FetchAsync should succeed", "FetchAsyncSuccess"); - var env = fetchResponse.OpenJObjectResponse()?["environment"]; + var env = fetchResponse.OpenJsonObjectResponse()?["environment"]; AssertLogger.AreEqual(name, env?["name"]?.ToString(), "Fetched name should match", "FetchedName"); AssertLogger.AreEqual(expectedUid, env?["uid"]?.ToString(), "Fetched uid should match create response", "FetchedUid"); } @@ -315,7 +315,7 @@ public async Task Test008_Should_Query_Environments_Async() ContentstackResponse queryResponse = await _stack.Environment().Query().FindAsync(); AssertLogger.IsTrue(queryResponse.IsSuccessStatusCode, "Query FindAsync should succeed", "QueryFindAsyncSuccess"); - var environments = queryResponse.OpenJObjectResponse()?["environments"] as JArray; + var environments = queryResponse.OpenJsonObjectResponse()?["environments"] as JsonArray; AssertLogger.IsNotNull(environments, "environments array"); AssertLogger.IsTrue( EnvironmentsArrayContainsName(environments, name), @@ -351,7 +351,7 @@ public async Task Test009_Should_Update_Environment_Async() ContentstackResponse fetchResponse = await _stack.Environment(updatedName).FetchAsync(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "FetchAsync after update should succeed", "FetchAsyncAfterUpdate"); - var env = fetchResponse.OpenJObjectResponse()?["environment"]; + var env = fetchResponse.OpenJsonObjectResponse()?["environment"]; AssertLogger.AreEqual(updatedName, env?["name"]?.ToString(), "Name should reflect update", "UpdatedName"); } finally @@ -1651,7 +1651,7 @@ public void Test066_Should_Fail_Create_Environment_With_Malformed_Json_Structure } catch (Exception ex) { - AssertLogger.IsTrue(ex is ContentstackErrorException || ex is Newtonsoft.Json.JsonException, + AssertLogger.IsTrue(ex is ContentstackErrorException || ex is System.Text.Json.JsonException, $"Expected JSON or API error: {ex.GetType().Name}", "JsonSerializationError"); } } @@ -1815,7 +1815,7 @@ public async Task Test070_Should_Validate_Environment_State_After_Failed_Operati ContentstackResponse fetchResponse = await _stack.Environment(name).FetchAsync(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "Fetch after failed update should succeed", "FetchAfterFailedUpdate"); - var env = fetchResponse.OpenJObjectResponse()?["environment"]; + var env = fetchResponse.OpenJsonObjectResponse()?["environment"]; AssertLogger.AreEqual(name, env?["name"]?.ToString(), "Name should be unchanged after failed update", "NameUnchangedAfterFailure"); } } @@ -1873,7 +1873,7 @@ public async Task Test072_Should_Handle_Large_Query_Result_Sets_Async() ContentstackResponse queryResponse = await _stack.Environment().Query().FindAsync(); AssertLogger.IsTrue(queryResponse.IsSuccessStatusCode, "Large query should succeed", "LargeQuerySuccess"); - var environments = queryResponse.OpenJObjectResponse()?["environments"] as JArray; + var environments = queryResponse.OpenJsonObjectResponse()?["environments"] as JsonArray; AssertLogger.IsNotNull(environments, "EnvironmentsArrayPresent"); // Validate that we can handle large result sets without memory issues diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack019_RoleTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack019_RoleTest.cs index 7d6921a..e6dfcbc 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack019_RoleTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack019_RoleTest.cs @@ -8,7 +8,7 @@ using Contentstack.Management.Core.Tests.Helpers; using Contentstack.Management.Core.Tests.Model; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json.Linq; +using System.Text.Json.Nodes; namespace Contentstack.Management.Core.Tests.IntegrationTest { @@ -40,7 +40,7 @@ public static void ClassCleanup() [TestInitialize] public void Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); } @@ -66,7 +66,7 @@ private static RoleModel BuildMinimalRoleModel(string uniqueName) private static string ParseRoleUid(ContentstackResponse response) { - var jo = response.OpenJObjectResponse(); + var jo = response.OpenJsonObjectResponse(); return jo?["role"]?["uid"]?.ToString(); } @@ -87,7 +87,7 @@ private void SafeDelete(string roleUid) } } - private static bool RolesArrayContainsUid(JArray roles, string uid) + private static bool RolesArrayContainsUid(JsonArray roles, string uid) { if (roles == null || string.IsNullOrEmpty(uid)) { @@ -324,7 +324,7 @@ public void Test001_Should_Create_Role_Sync() roleUid = ParseRoleUid(response); AssertLogger.IsNotNull(roleUid, "role uid"); - var jo = response.OpenJObjectResponse(); + var jo = response.OpenJsonObjectResponse(); AssertLogger.AreEqual(name, jo["role"]?["name"]?.ToString(), "Response name should match", "RoleName"); } finally @@ -349,7 +349,7 @@ public void Test002_Should_Fetch_Role_Sync() ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "Fetch should succeed", "FetchSyncSuccess"); - var role = fetchResponse.OpenJObjectResponse()?["role"]; + 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"); } @@ -375,7 +375,7 @@ public void Test003_Should_Query_Roles_Sync() ContentstackResponse queryResponse = _stack.Role().Query().Find(); AssertLogger.IsTrue(queryResponse.IsSuccessStatusCode, "Query Find should succeed", "QueryFindSuccess"); - var roles = queryResponse.OpenJObjectResponse()?["roles"] as JArray; + var roles = queryResponse.OpenJsonObjectResponse()?["roles"] as JsonArray; AssertLogger.IsNotNull(roles, "roles array"); AssertLogger.IsTrue( RolesArrayContainsUid(roles, roleUid), @@ -408,7 +408,7 @@ public void Test004_Should_Update_Role_Sync() ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "Fetch after update should succeed", "FetchAfterUpdate"); - var role = fetchResponse.OpenJObjectResponse()?["role"]; + var role = fetchResponse.OpenJsonObjectResponse()?["role"]; AssertLogger.AreEqual(updatedName, role?["name"]?.ToString(), "Name should reflect update", "UpdatedName"); } finally @@ -466,7 +466,7 @@ public async Task Test006_Should_Create_Role_Async() roleUid = ParseRoleUid(response); AssertLogger.IsNotNull(roleUid, "role uid"); - var jo = response.OpenJObjectResponse(); + var jo = response.OpenJsonObjectResponse(); AssertLogger.AreEqual(name, jo["role"]?["name"]?.ToString(), "Response name should match", "RoleName"); } finally @@ -491,7 +491,7 @@ public async Task Test007_Should_Fetch_Role_Async() ContentstackResponse fetchResponse = await _stack.Role(roleUid).FetchAsync(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "FetchAsync should succeed", "FetchAsyncSuccess"); - var role = fetchResponse.OpenJObjectResponse()?["role"]; + 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"); } @@ -517,7 +517,7 @@ public async Task Test008_Should_Query_Roles_Async() ContentstackResponse queryResponse = await _stack.Role().Query().FindAsync(); AssertLogger.IsTrue(queryResponse.IsSuccessStatusCode, "Query FindAsync should succeed", "QueryFindAsyncSuccess"); - var roles = queryResponse.OpenJObjectResponse()?["roles"] as JArray; + var roles = queryResponse.OpenJsonObjectResponse()?["roles"] as JsonArray; AssertLogger.IsNotNull(roles, "roles array"); AssertLogger.IsTrue( RolesArrayContainsUid(roles, roleUid), @@ -550,7 +550,7 @@ public async Task Test009_Should_Update_Role_Async() ContentstackResponse fetchResponse = await _stack.Role(roleUid).FetchAsync(); AssertLogger.IsTrue(fetchResponse.IsSuccessStatusCode, "FetchAsync after update should succeed", "FetchAsyncAfterUpdate"); - var role = fetchResponse.OpenJObjectResponse()?["role"]; + var role = fetchResponse.OpenJsonObjectResponse()?["role"]; AssertLogger.AreEqual(updatedName, role?["name"]?.ToString(), "Name should reflect update", "UpdatedName"); } finally @@ -888,11 +888,11 @@ public void Test023_Should_Accept_Create_Role_With_Null_Rules_Sync() AssertLogger.IsNotNull(roleUid, "NullRulesAccepted"); // Verify API accepted the request - detailed rule validation is optional - var responseContent = response.OpenJObjectResponse(); + var responseContent = response.OpenJsonObjectResponse(); if (responseContent?["role"] != null) { var role = responseContent["role"]; - var rules = role["rules"] as JArray; + var rules = role["rules"] as JsonArray; if (rules != null && rules.Count > 0) { AssertLogger.IsTrue(true, "DefaultRulesAdded"); @@ -941,7 +941,7 @@ public void Test024_Should_Accept_Create_Role_With_Empty_Rules_Sync() AssertLogger.IsNotNull(roleUid, "EmptyRulesAccepted"); // Verify API accepted the request - detailed rule validation is optional - var responseContent = response.OpenJObjectResponse(); + var responseContent = response.OpenJsonObjectResponse(); if (responseContent?["role"] != null) { AssertLogger.IsTrue(true, "EmptyRulesHandledByAPI"); @@ -985,7 +985,7 @@ public void Test025_Should_Accept_Create_Role_With_Empty_Branches_Sync() AssertLogger.IsNotNull(roleUid, "EmptyBranchesAccepted"); // Verify API accepted the request - detailed branch validation is optional - var responseContent = response.OpenJObjectResponse(); + var responseContent = response.OpenJsonObjectResponse(); if (responseContent?["role"] != null) { AssertLogger.IsTrue(true, "EmptyBranchesHandledByAPI"); @@ -1029,7 +1029,7 @@ public void Test026_Should_Accept_Create_Role_With_Nonexistent_Branch_Sync() AssertLogger.IsNotNull(roleUid, "NonexistentBranchAccepted"); // Verify API accepted the request - detailed branch validation is optional - var responseContent = response.OpenJObjectResponse(); + var responseContent = response.OpenJsonObjectResponse(); if (responseContent?["role"] != null) { AssertLogger.IsTrue(true, "NonexistentBranchHandledByAPI"); @@ -1144,7 +1144,7 @@ public void Test029_Should_Accept_Update_Role_With_Empty_Name_Sync() AssertLogger.IsTrue(true, "EmptyNameUpdateAccepted"); // Verify API preserved original name when empty name provided - var role = updateResponse.OpenJObjectResponse()?["role"]; + var role = updateResponse.OpenJsonObjectResponse()?["role"]; var currentName = role?["name"]?.ToString(); AssertLogger.AreEqual(originalName, currentName, "OriginalNamePreserved"); AssertLogger.IsTrue(!string.IsNullOrEmpty(currentName), "NameNotEmpty"); @@ -1401,7 +1401,7 @@ public async Task Test035_Should_Accept_Update_Role_With_Empty_Name_Async() AssertLogger.IsTrue(true, "EmptyNameUpdateAcceptedAsync"); // Verify API preserved original name when empty name provided - var role = updateResponse.OpenJObjectResponse()?["role"]; + var role = updateResponse.OpenJsonObjectResponse()?["role"]; var currentName = role?["name"]?.ToString(); AssertLogger.AreEqual(originalName, currentName, "OriginalNamePreservedAsync"); AssertLogger.IsTrue(!string.IsNullOrEmpty(currentName), "NameNotEmptyAsync"); @@ -2264,7 +2264,7 @@ public void Test054_Should_Handle_Unicode_Characters_In_Role_Name_Sync() ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch(); if (fetchResponse.IsSuccessStatusCode) { - var role = fetchResponse.OpenJObjectResponse()?["role"]; + var role = fetchResponse.OpenJsonObjectResponse()?["role"]; var fetchedName = role?["name"]?.ToString(); AssertLogger.AreEqual(unicodeName, fetchedName, "Unicode name should be preserved", "UnicodePreserved"); } @@ -2360,7 +2360,7 @@ public void Test056_Should_Handle_Stack_Role_Limits_Sync() else if (response.StatusCode == (HttpStatusCode)422) // Unprocessable Entity { // Check for role limit error (Error Code 157) - var errorContent = response.OpenJObjectResponse(); + var errorContent = response.OpenJsonObjectResponse(); var errorCode = errorContent?["error_code"]?.ToString(); if (errorCode == "157") @@ -2574,7 +2574,7 @@ public void Test059_Should_Handle_Concurrent_Role_Modifications_Sync() ContentstackResponse fetchResponse = _stack.Role(roleUid).Fetch(); if (fetchResponse.IsSuccessStatusCode) { - var role = fetchResponse.OpenJObjectResponse()?["role"]; + var role = fetchResponse.OpenJsonObjectResponse()?["role"]; AssertLogger.IsNotNull(role, "ConcurrentFinalState"); } diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack020_WorkflowTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack020_WorkflowTest.cs index 851bfcb..9f53dc9 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack020_WorkflowTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack020_WorkflowTest.cs @@ -10,8 +10,6 @@ using Contentstack.Management.Core.Tests.Model; using Contentstack.Management.Core.Utils; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; -using Newtonsoft.Json.Linq; namespace Contentstack.Management.Core.Tests.IntegrationTest { @@ -42,7 +40,7 @@ public static void ClassInitialize(TestContext context) _client = Contentstack.CreateAuthenticatedClient(); // Initialize stack for content type operations - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _testStack = _client.Stack(response.Stack.APIKey); // Create dedicated test content types for better isolation @@ -62,7 +60,7 @@ public static void ClassCleanup() [TestInitialize] public void Initialize() { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); _stack = _client.Stack(response.Stack.APIKey); // Clear tracking lists for this test @@ -110,8 +108,8 @@ private void VerifyCleanTestEnvironment() ContentstackResponse workflowResponse = _stack.Workflow().FindAll(); if (workflowResponse.IsSuccessStatusCode) { - var jObject = workflowResponse.OpenJObjectResponse(); - var workflowsArray = jObject["workflows"] as JArray; + var jObject = workflowResponse.OpenJsonObjectResponse(); + var workflowsArray = jObject["workflows"] as JsonArray; if (workflowsArray != null && workflowsArray.Count > 0) { @@ -131,8 +129,8 @@ private void VerifyCleanTestEnvironment() ContentstackResponse publishRulesResponse = _stack.Workflow().PublishRule().FindAll(); if (publishRulesResponse.IsSuccessStatusCode) { - var jObject = publishRulesResponse.OpenJObjectResponse(); - var publishRulesArray = jObject["publishing_rules"] as JArray; + var jObject = publishRulesResponse.OpenJsonObjectResponse(); + var publishRulesArray = jObject["publishing_rules"] as JsonArray; if (publishRulesArray != null && publishRulesArray.Count > 0) { @@ -280,8 +278,8 @@ private List GetWorkflowContentTypes(string workflowUid) ContentstackResponse response = _stack.Workflow(workflowUid).Fetch(); if (response.IsSuccessStatusCode) { - var workflowJson = response.OpenJObjectResponse(); - var contentTypesArray = workflowJson["workflow"]?["content_types"] as JArray; + var workflowJson = response.OpenJsonObjectResponse(); + var contentTypesArray = workflowJson["workflow"]?["content_types"] as JsonArray; if (contentTypesArray != null) { @@ -316,8 +314,8 @@ private async Task EnsureTestEnvironmentAsync() ContentstackResponse envResponse = _stack.Environment().Query().Find(); if (envResponse.IsSuccessStatusCode) { - var envJson = envResponse.OpenJObjectResponse(); - var environments = envJson["environments"] as JArray; + var envJson = envResponse.OpenJsonObjectResponse(); + var environments = envJson["environments"] as JsonArray; if (environments != null && environments.Count > 0) { _testEnvironmentUid = environments[0]["uid"]?.ToString(); @@ -342,7 +340,7 @@ private async Task EnsureTestEnvironmentAsync() ContentstackResponse response = _stack.Environment().Create(environmentModel); if (response.IsSuccessStatusCode) { - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); _testEnvironmentUid = responseJson["environment"]?["uid"]?.ToString(); } } @@ -590,8 +588,8 @@ private void DiscoverAvailableContentTypes() if (!response.IsSuccessStatusCode) return; - var jObject = response.OpenJObjectResponse(); - var contentTypesArray = jObject["content_types"] as JArray; + var jObject = response.OpenJsonObjectResponse(); + var contentTypesArray = jObject["content_types"] as JsonArray; if (contentTypesArray != null) { @@ -640,8 +638,8 @@ private void CleanupConflictingWorkflows() if (!response.IsSuccessStatusCode) return; // Ignore cleanup failures - var jObject = response.OpenJObjectResponse(); - var workflowsArray = jObject["workflows"] as JArray; + var jObject = response.OpenJsonObjectResponse(); + var workflowsArray = jObject["workflows"] as JsonArray; if (workflowsArray != null) { @@ -690,8 +688,8 @@ private void CleanupPublishRulesForWorkflow(string workflowUid) if (!response.IsSuccessStatusCode) return; - var jObject = response.OpenJObjectResponse(); - var publishRulesArray = jObject["publishing_rules"] as JArray; + var jObject = response.OpenJsonObjectResponse(); + var publishRulesArray = jObject["publishing_rules"] as JsonArray; if (publishRulesArray != null) { @@ -1172,7 +1170,7 @@ public void Test001_Should_Create_Workflow_With_Minimum_Required_Stages() // Act ContentstackResponse response = _stack.Workflow().Create(workflowModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "workflowCreateResponse"); @@ -1184,7 +1182,7 @@ public void Test001_Should_Create_Workflow_With_Minimum_Required_Stages() _createdWorkflowUids.Add(workflowUid); TestOutputLogger.LogContext("WorkflowUid", workflowUid); - var stages = responseJson["workflow"]["workflow_stages"] as JArray; + var stages = responseJson["workflow"]["workflow_stages"] as JsonArray; AssertLogger.AreEqual(2, stages?.Count, "Expected exactly 2 stages (API minimum)", "stageCount"); AssertLogger.AreEqual(workflowName, responseJson["workflow"]["name"]?.ToString(), "workflowName"); } @@ -1207,7 +1205,7 @@ public void Test002_Should_Create_Workflow_With_Multiple_Stages() // Act ContentstackResponse response = _stack.Workflow().Create(workflowModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "workflowCreateResponse"); @@ -1218,7 +1216,7 @@ public void Test002_Should_Create_Workflow_With_Multiple_Stages() _createdWorkflowUids.Add(workflowUid); TestOutputLogger.LogContext("WorkflowUid", workflowUid); - var stages = responseJson["workflow"]["workflow_stages"] as JArray; + var stages = responseJson["workflow"]["workflow_stages"] as JsonArray; AssertLogger.AreEqual(3, stages?.Count, "Expected exactly 3 stages", "stageCount"); // Verify all stages were created with correct names @@ -1245,13 +1243,13 @@ public void Test003_Should_Fetch_Single_Workflow_By_Uid() var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); // Act ContentstackResponse response = _stack.Workflow(workflowUid).Fetch(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "workflowFetchResponse"); @@ -1260,7 +1258,7 @@ public void Test003_Should_Fetch_Single_Workflow_By_Uid() AssertLogger.AreEqual(workflowUid, responseJson["workflow"]["uid"]?.ToString(), "workflowUid"); AssertLogger.AreEqual(workflowName, responseJson["workflow"]["name"]?.ToString(), "workflowName"); - var stages = responseJson["workflow"]["workflow_stages"] as JArray; + var stages = responseJson["workflow"]["workflow_stages"] as JsonArray; AssertLogger.AreEqual(2, stages?.Count, "Expected 2 stages", "stageCount"); TestOutputLogger.LogContext("FetchedWorkflowUid", workflowUid); } @@ -1279,14 +1277,14 @@ public void Test004_Should_Fetch_All_Workflows() { // Act ContentstackResponse response = _stack.Workflow().FindAll(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "workflowFindAllResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Workflow FindAll failed with status {(int)response.StatusCode}", "workflowFindAllSuccess"); // Response should contain workflows array (even if empty) - var workflows = (responseJson["workflows"] as JArray) ?? (responseJson["workflow"] as JArray); + var workflows = (responseJson["workflows"] as JsonArray) ?? (responseJson["workflow"] as JsonArray); AssertLogger.IsNotNull(workflows, "workflowsArray"); TestOutputLogger.LogContext("WorkflowCount", workflows.Count.ToString()); @@ -1309,7 +1307,7 @@ public void Test005_Should_Update_Workflow_Properties() var workflowModel = CreateTestWorkflowModel(originalName, 2); ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -1320,14 +1318,14 @@ public void Test005_Should_Update_Workflow_Properties() // Act ContentstackResponse response = _stack.Workflow(workflowUid).Update(workflowModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "workflowUpdateResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Workflow update failed with status {(int)response.StatusCode}", "workflowUpdateSuccess"); AssertLogger.IsNotNull(responseJson["workflow"], "workflowObject"); AssertLogger.AreEqual(updatedName, responseJson["workflow"]["name"]?.ToString(), "updatedWorkflowName"); - AssertLogger.AreEqual(false, responseJson["workflow"]["enabled"]?.Value(), "updatedEnabledStatus"); + AssertLogger.AreEqual(false, responseJson["workflow"]?["enabled"]?.GetValue(), "updatedEnabledStatus"); TestOutputLogger.LogContext("UpdatedWorkflowUid", workflowUid); } @@ -1349,7 +1347,7 @@ public void Test006_Should_Add_New_Stage_To_Existing_Workflow() var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -1357,13 +1355,13 @@ public void Test006_Should_Add_New_Stage_To_Existing_Workflow() // Act ContentstackResponse response = _stack.Workflow(workflowUid).Update(workflowModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "workflowUpdateResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Workflow update failed with status {(int)response.StatusCode}", "workflowUpdateSuccess"); - var stages = responseJson["workflow"]["workflow_stages"] as JArray; + var stages = responseJson["workflow"]["workflow_stages"] as JsonArray; AssertLogger.AreEqual(3, stages?.Count, "Expected 3 stages after update", "stageCount"); TestOutputLogger.LogContext("WorkflowWithNewStageUid", workflowUid); @@ -1387,7 +1385,7 @@ public void Test007_Should_Enable_Workflow_Successfully() workflowModel.Enabled = false; ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -1419,7 +1417,7 @@ public void Test008_Should_Disable_Workflow_Successfully() workflowModel.Enabled = true; ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -1453,11 +1451,11 @@ public async Task Test009_Should_Create_Publish_Rule_For_Workflow_Stage() var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[1]["uid"].ToString(); // Use second stage // Create publish rule @@ -1465,7 +1463,7 @@ public async Task Test009_Should_Create_Publish_Rule_For_Workflow_Stage() // Act ContentstackResponse response = _stack.Workflow().PublishRule().Create(publishRuleModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "publishRuleCreateResponse"); @@ -1495,14 +1493,14 @@ public void Test010_Should_Fetch_All_Publish_Rules() { // Act ContentstackResponse response = _stack.Workflow().PublishRule().FindAll(); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "publishRuleFindAllResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Publish rule FindAll failed with status {(int)response.StatusCode}", "publishRuleFindAllSuccess"); // Response should contain publishing_rules array (even if empty) - var rules = (responseJson["publishing_rules"] as JArray) ?? (responseJson["publishing_rule"] as JArray); + var rules = (responseJson["publishing_rules"] as JsonArray) ?? (responseJson["publishing_rule"] as JsonArray); AssertLogger.IsNotNull(rules, "publishingRulesArray"); TestOutputLogger.LogContext("PublishRuleCount", rules.Count.ToString()); @@ -1531,18 +1529,18 @@ public async Task Test011_Should_Get_Publish_Rules_By_Content_Type() var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateTestPublishRuleModel(workflowUid, stageUid, _testEnvironmentUid); publishRuleModel.ContentTypes = new List { contentTypeUid }; ContentstackResponse ruleResponse = _stack.Workflow().PublishRule().Create(publishRuleModel); - var ruleJson = ruleResponse.OpenJObjectResponse(); + var ruleJson = ruleResponse.OpenJsonObjectResponse(); string publishRuleUid = ruleJson["publishing_rule"]["uid"].ToString(); _createdPublishRuleUids.Add(publishRuleUid); @@ -1577,16 +1575,16 @@ public async Task Test012_Should_Update_Publish_Rule() var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateTestPublishRuleModel(workflowUid, stageUid, _testEnvironmentUid); ContentstackResponse ruleResponse = _stack.Workflow().PublishRule().Create(publishRuleModel); - var ruleJson = ruleResponse.OpenJObjectResponse(); + var ruleJson = ruleResponse.OpenJsonObjectResponse(); string publishRuleUid = ruleJson["publishing_rule"]["uid"].ToString(); _createdPublishRuleUids.Add(publishRuleUid); @@ -1596,12 +1594,12 @@ public async Task Test012_Should_Update_Publish_Rule() // Act ContentstackResponse response = _stack.Workflow().PublishRule(publishRuleUid).Update(publishRuleModel); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "publishRuleUpdateResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Publish rule update failed with status {(int)response.StatusCode}", "publishRuleUpdateSuccess"); - AssertLogger.AreEqual(true, responseJson["publishing_rule"]["disable_approver_publishing"]?.Value(), "updatedDisableApproval"); + AssertLogger.AreEqual(true, responseJson["publishing_rule"]?["disable_approver_publishing"]?.GetValue(), "updatedDisableApproval"); TestOutputLogger.LogContext("UpdatedPublishRuleUid", publishRuleUid); } @@ -1624,13 +1622,13 @@ public void Test013_Should_Fetch_Workflows_With_Include_Parameters() collection.Add("include_publish_details", "true"); ContentstackResponse response = _stack.Workflow().FindAll(collection); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "workflowFindAllWithIncludeResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Workflow FindAll with include failed with status {(int)response.StatusCode}", "workflowFindAllWithIncludeSuccess"); - var workflows = (responseJson["workflows"] as JArray) ?? (responseJson["workflow"] as JArray); + var workflows = (responseJson["workflows"] as JsonArray) ?? (responseJson["workflow"] as JsonArray); AssertLogger.IsNotNull(workflows, "workflowsArray"); TestOutputLogger.LogContext("IncludeParameters", "include_count,include_publish_details"); @@ -1654,13 +1652,13 @@ public void Test014_Should_Fetch_Workflows_With_Pagination() collection.Add("skip", "0"); ContentstackResponse response = _stack.Workflow().FindAll(collection); - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); // Assert AssertLogger.IsNotNull(response, "workflowPaginationResponse"); AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Workflow FindAll with pagination failed with status {(int)response.StatusCode}", "workflowPaginationSuccess"); - var workflows = (responseJson["workflows"] as JArray) ?? (responseJson["workflow"] as JArray); + var workflows = (responseJson["workflows"] as JsonArray) ?? (responseJson["workflow"] as JsonArray); AssertLogger.IsNotNull(workflows, "workflowsArray"); TestOutputLogger.LogContext("PaginationParams", "limit=5,skip=0"); @@ -1686,16 +1684,16 @@ public async Task Test015_Should_Delete_Publish_Rule_Successfully() var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateTestPublishRuleModel(workflowUid, stageUid, _testEnvironmentUid); ContentstackResponse ruleResponse = _stack.Workflow().PublishRule().Create(publishRuleModel); - var ruleJson = ruleResponse.OpenJObjectResponse(); + var ruleJson = ruleResponse.OpenJsonObjectResponse(); string publishRuleUid = ruleJson["publishing_rule"]["uid"].ToString(); // Act @@ -1823,7 +1821,7 @@ public void Test103_Should_Fail_Create_Duplicate_Workflow_Name() ContentstackResponse response1 = _stack.Workflow().Create(workflowModel1); AssertLogger.IsTrue(response1.IsSuccessStatusCode, "First workflow creation should succeed", "firstWorkflowCreated"); - var responseJson1 = response1.OpenJObjectResponse(); + var responseJson1 = response1.OpenJsonObjectResponse(); string workflowUid1 = responseJson1["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid1); @@ -1995,16 +1993,16 @@ public async Task Test108_Should_Allow_Delete_Workflow_With_Active_Publish_Rules var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateTestPublishRuleModel(workflowUid, stageUid, _testEnvironmentUid); ContentstackResponse ruleResponse = _stack.Workflow().PublishRule().Create(publishRuleModel); - var ruleJson = ruleResponse.OpenJObjectResponse(); + var ruleJson = ruleResponse.OpenJsonObjectResponse(); string publishRuleUid = ruleJson["publishing_rule"]["uid"].ToString(); _createdPublishRuleUids.Add(publishRuleUid); @@ -2061,7 +2059,7 @@ public void Test110_Should_Delete_Workflow_Successfully_After_Cleanup() var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); // Act @@ -2139,7 +2137,7 @@ public void Test112_Should_Accept_Create_Workflow_With_Whitespace_Only_Name() if (response.IsSuccessStatusCode) { - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); string workflowUid = responseJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); } @@ -2197,7 +2195,7 @@ public void Test114_Should_Accept_Create_Workflow_With_Invalid_Characters_In_Nam if (response.IsSuccessStatusCode) { - var workflowUid = response.OpenJObjectResponse()["workflow"]?["uid"]?.ToString(); + var workflowUid = response.OpenJsonObjectResponse()["workflow"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(workflowUid)) { TrackWorkflowForCleanup(workflowUid, workflowModel.Name); @@ -2332,7 +2330,7 @@ public void Test119_Should_Accept_Create_Workflow_With_Invalid_Branch_Names() if (response.IsSuccessStatusCode) { - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); string workflowUid = responseJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); } @@ -2439,7 +2437,7 @@ public void Test122_Should_Accept_Create_Stage_With_Invalid_Color_Format() if (response.IsSuccessStatusCode) { - var workflowUid = response.OpenJObjectResponse()["workflow"]?["uid"]?.ToString(); + var workflowUid = response.OpenJsonObjectResponse()["workflow"]?["uid"]?.ToString(); if (!string.IsNullOrEmpty(workflowUid)) { _createdWorkflowUids.Add(workflowUid); @@ -2605,11 +2603,11 @@ public async Task Test126_Should_Fail_Create_Publish_Rule_With_Missing_Environme workflowModel.ContentTypes = new List { GetValidContentTypeUid() }; // Use real content type UID ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateInvalidPublishRuleModel("missing_environment", workflowUid, stageUid); @@ -2642,11 +2640,11 @@ public async Task Test127_Should_Fail_Create_Publish_Rule_With_Invalid_Environme workflowModel.ContentTypes = new List { GetValidContentTypeUid() }; // Use real content type UID ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateInvalidPublishRuleModel("invalid_environment", workflowUid, stageUid); @@ -2733,11 +2731,11 @@ public async Task Test130_Should_Fail_Create_Publish_Rule_With_Invalid_Content_T workflowModel.ContentTypes = new List { GetValidContentTypeUid() }; // Use real content type UID ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateInvalidPublishRuleModel("invalid_content_types", workflowUid, stageUid, _testEnvironmentUid); @@ -2773,11 +2771,11 @@ public async Task Test131_Should_Fail_Create_Publish_Rule_With_Invalid_Locales() workflowModel.ContentTypes = new List { GetValidContentTypeUid() }; // Use real content type UID ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateInvalidPublishRuleModel("invalid_locales", workflowUid, stageUid, _testEnvironmentUid); @@ -2813,11 +2811,11 @@ public async Task Test132_Should_Fail_Create_Publish_Rule_With_Empty_Branches() workflowModel.ContentTypes = new List { GetValidContentTypeUid() }; // Use real content type UID ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); var publishRuleModel = CreateInvalidPublishRuleModel("empty_branches", workflowUid, stageUid, _testEnvironmentUid); @@ -2929,7 +2927,7 @@ public void Test135_Should_Fail_With_Insufficient_Permissions() else { // Clean up if it succeeded - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); string workflowUid = responseJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); } @@ -2966,7 +2964,7 @@ public void Test136_Should_Fail_Enable_Already_Enabled_Workflow() workflowModel.Enabled = true; // Already enabled ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -3012,7 +3010,7 @@ public void Test137_Should_Fail_Disable_Already_Disabled_Workflow() workflowModel.Enabled = false; // Already disabled ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -3057,7 +3055,7 @@ public void Test138_Should_Fail_Update_Workflow_To_Invalid_State() var workflowModel = CreateTestWorkflowModel(workflowName, 2); ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -3306,7 +3304,7 @@ public void Test146_Should_Handle_Concurrent_Workflow_Modifications() workflowModel.ContentTypes = new List { GetValidContentTypeUid() }; // Use real content type UID ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -3355,7 +3353,7 @@ public void Test147_Should_Handle_Race_Conditions_In_Workflow_State_Changes() workflowModel.ContentTypes = new List { GetValidContentTypeUid() }; // Use real content type UID ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -3431,7 +3429,7 @@ public void Test148_Should_Handle_Network_Timeout_Gracefully() if (response.IsSuccessStatusCode) { - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); string workflowUid = responseJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); AssertLogger.IsTrue(true, "Large workflow creation succeeded", "timeoutGracefulSuccess"); @@ -3483,7 +3481,7 @@ public void Test149_Should_Handle_Admin_Users_Validation_Errors() if (response.IsSuccessStatusCode) { // If it succeeds unexpectedly, clean up and note the behavior - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); string workflowUid = responseJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); AssertLogger.IsTrue(true, "API unexpectedly accepted invalid admin_users configuration", "adminUsersAccepted"); @@ -3535,17 +3533,17 @@ public async Task Test150_Should_Fail_Create_Publish_Rule_With_Duplicate_Conditi workflowModel.ContentTypes = new List { GetValidContentTypeUid() }; // Use real content type UID ContentstackResponse workflowResponse = _stack.Workflow().Create(workflowModel); - var workflowJson = workflowResponse.OpenJObjectResponse(); + var workflowJson = workflowResponse.OpenJsonObjectResponse(); string workflowUid = workflowJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); - var stages = workflowJson["workflow"]["workflow_stages"] as JArray; + var stages = workflowJson["workflow"]["workflow_stages"] as JsonArray; string stageUid = stages[0]["uid"].ToString(); // Create first publish rule var publishRuleModel1 = CreateTestPublishRuleModel(workflowUid, stageUid, _testEnvironmentUid); ContentstackResponse ruleResponse1 = _stack.Workflow().PublishRule().Create(publishRuleModel1); - var ruleJson1 = ruleResponse1.OpenJObjectResponse(); + var ruleJson1 = ruleResponse1.OpenJsonObjectResponse(); string publishRuleUid1 = ruleJson1["publishing_rule"]["uid"].ToString(); _createdPublishRuleUids.Add(publishRuleUid1); @@ -3565,7 +3563,7 @@ public async Task Test150_Should_Fail_Create_Publish_Rule_With_Duplicate_Conditi else { // API allowed duplicate - add to cleanup - var ruleJson2 = ruleResponse2.OpenJObjectResponse(); + var ruleJson2 = ruleResponse2.OpenJsonObjectResponse(); string publishRuleUid2 = ruleJson2["publishing_rule"]["uid"].ToString(); _createdPublishRuleUids.Add(publishRuleUid2); AssertLogger.IsTrue(true, "API allows duplicate publish rule conditions", "duplicateRuleAllowed"); @@ -3599,7 +3597,7 @@ public void Test151_Should_Fail_Update_Workflow_With_Invalid_Stage_Transitions() var workflowModel = CreateTestWorkflowModel(workflowName, 3); ContentstackResponse createResponse = _stack.Workflow().Create(workflowModel); - var createJson = createResponse.OpenJObjectResponse(); + var createJson = createResponse.OpenJsonObjectResponse(); string workflowUid = createJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); @@ -3704,7 +3702,7 @@ public void Test152_Should_Fail_Create_Workflow_With_Malformed_JSON_Structure() } else { - var responseJson = response.OpenJObjectResponse(); + var responseJson = response.OpenJsonObjectResponse(); string workflowUid = responseJson["workflow"]["uid"].ToString(); _createdWorkflowUids.Add(workflowUid); AssertLogger.IsTrue(true, "API accepts malformed JSON structure", "malformedJSONAccepted"); diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack021_EntryVariantTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack021_EntryVariantTest.cs index f3d8fab..b13ba35 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack021_EntryVariantTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack021_EntryVariantTest.cs @@ -10,21 +10,19 @@ using Contentstack.Management.Core.Tests.Helpers; using Contentstack.Management.Core.Tests.Model; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; -using Newtonsoft.Json.Linq; using Contentstack.Management.Core.Abstractions; namespace Contentstack.Management.Core.Tests.IntegrationTest { public class ProductBannerEntry : IEntry { - [JsonProperty("title")] + [JsonPropertyName("title")] public string Title { get; set; } - [JsonProperty("banner_title")] + [JsonPropertyName("banner_title")] public string BannerTitle { get; set; } - [JsonProperty("banner_color")] + [JsonPropertyName("banner_color")] public string BannerColor { get; set; } } @@ -241,7 +239,7 @@ public void TestInitialize() // Optional: Fallback to stackApiKey.txt if it's missing in appSettings.json if (string.IsNullOrEmpty(apiKey)) { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); apiKey = response.Stack.APIKey; } @@ -262,8 +260,8 @@ public async System.Threading.Tasks.Task Test001_Ensure_Setup_Data() var vgResponse = await _stack.VariantGroup().FindAsync(collection); Console.WriteLine("Variant Groups Response: " + vgResponse.OpenResponse()); - var vgJObject = vgResponse.OpenJObjectResponse(); - var groups = vgJObject["variant_groups"] as JArray; + var vgJObject = vgResponse.OpenJsonObjectResponse(); + var groups = vgJObject["variant_groups"] as JsonArray; if (groups == null || groups.Count == 0) { @@ -273,14 +271,14 @@ public async System.Threading.Tasks.Task Test001_Ensure_Setup_Data() _variantGroupUid = groups[0]["uid"]?.ToString(); - var variantsArray = groups[0]["variants"] as JArray; + var variantsArray = groups[0]["variants"] as JsonArray; if (variantsArray != null && variantsArray.Count > 0) { _variantUid = variantsArray[0]["uid"]?.ToString(); } else { - var variantUids = groups[0]["variant_uids"] as JArray; + var variantUids = groups[0]["variant_uids"] as JsonArray; if (variantUids != null && variantUids.Count > 0) { _variantUid = variantUids[0].ToString(); @@ -352,7 +350,7 @@ public async System.Threading.Tasks.Task Test001_Ensure_Setup_Data() // 4. Ensure Base Entry exists var queryResp = await _stack.ContentType(_contentTypeUid).Entry().Query().FindAsync(); - var entriesArray = queryResp.OpenJObjectResponse()["entries"] as JArray; + var entriesArray = queryResp.OpenJsonObjectResponse()["entries"] as JsonArray; if (entriesArray != null && entriesArray.Count > 0) { @@ -369,7 +367,7 @@ public async System.Threading.Tasks.Task Test001_Ensure_Setup_Data() var entryResponse = await _stack.ContentType(_contentTypeUid).Entry().CreateAsync(entryData); Assert.IsTrue(entryResponse.IsSuccessStatusCode, "Should create base entry: " + entryResponse.OpenResponse()); - var entryObj = entryResponse.OpenJObjectResponse()["entry"]; + var entryObj = entryResponse.OpenJsonObjectResponse()["entry"]; _entryUid = entryObj["uid"]?.ToString(); } @@ -1679,7 +1677,7 @@ public void Test042_Should_Fail_Operations_With_Unlinked_Variant_Group_Sync() return; } - var entryObj = entryResponse.OpenJObjectResponse()["entry"]; + var entryObj = entryResponse.OpenJsonObjectResponse()["entry"]; tempEntryUid = entryObj["uid"]?.ToString(); // Try to create variant - should fail since content type is not linked to variant group @@ -2047,7 +2045,7 @@ public async Task Test050_Should_Fail_Operations_With_Unlinked_Variant_Group_Asy return; } - var entryObj = entryResponse.OpenJObjectResponse()["entry"]; + var entryObj = entryResponse.OpenJsonObjectResponse()["entry"]; tempEntryUid = entryObj["uid"]?.ToString(); // Try to create variant - should fail @@ -3454,10 +3452,10 @@ await AssertLogger.ThrowsContentstackErrorAsync(async () => /// public class SimpleTestEntry : IEntry { - [JsonProperty(propertyName: "title")] + [JsonPropertyName("title")] public string Title { get; set; } - [JsonProperty(propertyName: "_variant")] + [JsonPropertyName("_variant")] public object Variant { get; set; } } } \ No newline at end of file diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack022_VariantGroupTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack022_VariantGroupTest.cs index 2363ad5..b0fb5f0 100644 --- a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack022_VariantGroupTest.cs +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack022_VariantGroupTest.cs @@ -11,8 +11,6 @@ using Contentstack.Management.Core.Queryable; using Contentstack.Management.Core.Exceptions; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json.Linq; - namespace Contentstack.Management.Core.Tests.IntegrationTest { [TestClass] @@ -205,7 +203,7 @@ public void TestInitialize() // Optional: Fallback to stackApiKey.txt if it's missing in appSettings.json if (string.IsNullOrEmpty(apiKey)) { - StackResponse response = StackResponse.getStack(_client.serializer); + StackResponse response = StackResponse.getStack(_client.SerializerOptions); apiKey = response.Stack.APIKey; } @@ -229,8 +227,8 @@ public async Task Test001_Should_Find_All_VariantGroups() Assert.IsTrue(response.IsSuccessStatusCode, $"Should successfully fetch variant groups: {response.OpenResponse()}"); - var jObject = response.OpenJObjectResponse(); - var variantGroups = jObject["variant_groups"] as JArray; + var jObject = response.OpenJsonObjectResponse(); + var variantGroups = jObject["variant_groups"] as JsonArray; Assert.IsNotNull(variantGroups, "Variant groups array should not be null"); Console.WriteLine($"Found {variantGroups.Count} variant groups"); @@ -264,7 +262,7 @@ public async Task Test002_Should_Find_VariantGroups_With_Pagination() Assert.IsTrue(response.IsSuccessStatusCode, $"Should successfully fetch variant groups with pagination: {response.OpenResponse()}"); - var jObject = response.OpenJObjectResponse(); + var jObject = response.OpenJsonObjectResponse(); Assert.IsNotNull(jObject["variant_groups"], "Should have variant_groups array"); // Check if count is included when requested @@ -273,7 +271,7 @@ public async Task Test002_Should_Find_VariantGroups_With_Pagination() Console.WriteLine($"Total count: {jObject["count"]}"); } - var variantGroups = jObject["variant_groups"] as JArray; + var variantGroups = jObject["variant_groups"] as JsonArray; Console.WriteLine($"Returned {variantGroups.Count} variant groups with pagination"); // Verify pagination worked - should return at most 5 items @@ -298,8 +296,8 @@ public async Task Test003_Should_Discover_Available_ContentTypes() return; } - var jObject = contentTypesResponse.OpenJObjectResponse(); - var contentTypesArray = jObject["content_types"] as JArray; + var jObject = contentTypesResponse.OpenJsonObjectResponse(); + var contentTypesArray = jObject["content_types"] as JsonArray; if (contentTypesArray == null || contentTypesArray.Count == 0) { @@ -359,7 +357,7 @@ public async Task Test004_Should_Successfully_Link_Single_ContentType() Console.WriteLine($"✅ Successfully linked content type {_testContentTypeUid} to variant group {_testVariantGroupUid}"); // Verify the response structure - var responseObj = linkResponse.OpenJObjectResponse(); + var responseObj = linkResponse.OpenJsonObjectResponse(); Assert.IsNotNull(responseObj, "Response should contain JSON object"); } else @@ -574,8 +572,8 @@ public async Task Test009_Should_Handle_Various_Query_Parameters() Assert.IsTrue(response.IsSuccessStatusCode, $"Should work with query parameters: {response.OpenResponse()}"); - var jObject = response.OpenJObjectResponse(); - var variantGroups = jObject["variant_groups"] as JArray; + var jObject = response.OpenJsonObjectResponse(); + var variantGroups = jObject["variant_groups"] as JsonArray; Assert.IsNotNull(variantGroups, "Should have variant_groups array with advanced parameters"); Console.WriteLine($"✅ Found {variantGroups.Count} variant groups with advanced query parameters"); diff --git a/Contentstack.Management.Core.Tests/Model/Models.cs b/Contentstack.Management.Core.Tests/Model/Models.cs index 6e05f70..8992f13 100644 --- a/Contentstack.Management.Core.Tests/Model/Models.cs +++ b/Contentstack.Management.Core.Tests/Model/Models.cs @@ -1,56 +1,57 @@ -using Newtonsoft.Json; -using Contentstack.Management.Core.Models; using System.Collections.Generic; +using System.Text.Json.Serialization; +using Contentstack.Management.Core.Models; namespace Contentstack.Management.Core.Tests.Model { public class GlobalFieldModel { - [JsonProperty("global_field")] + [JsonPropertyName("global_field")] public ContentModelling Modelling { get; set; } } + public class GlobalFieldsModel { - [JsonProperty("global_fields")] + [JsonPropertyName("global_fields")] public List Modellings { get; set; } } public class ContentTypeModel { - [JsonProperty("content_type")] + [JsonPropertyName("content_type")] public ContentModelling Modelling { get; set; } } + public class ContentTypesModel { - [JsonProperty("content_types")] + [JsonPropertyName("content_types")] public List Modellings { get; set; } } public class TaxonomyResponseModel { - [JsonProperty("taxonomy")] + [JsonPropertyName("taxonomy")] public TaxonomyModel Taxonomy { get; set; } } public class TaxonomiesResponseModel { - [JsonProperty("taxonomies")] + [JsonPropertyName("taxonomies")] public List Taxonomies { get; set; } } public class TermResponseModel { - [JsonProperty("term")] + [JsonPropertyName("term")] public TermModel Term { get; set; } } public class TermsResponseModel { - [JsonProperty("terms")] + [JsonPropertyName("terms")] public List Terms { get; set; } - [JsonProperty("count")] + [JsonPropertyName("count")] public int? Count { get; set; } } } - diff --git a/Contentstack.Management.Core.Tests/Model/MultiPageEntry.cs b/Contentstack.Management.Core.Tests/Model/MultiPageEntry.cs index 1d387dd..3290f22 100644 --- a/Contentstack.Management.Core.Tests/Model/MultiPageEntry.cs +++ b/Contentstack.Management.Core.Tests/Model/MultiPageEntry.cs @@ -1,5 +1,5 @@ +using System.Text.Json.Serialization; using Contentstack.Management.Core.Models; -using Newtonsoft.Json; using Contentstack.Management.Core.Abstractions; namespace Contentstack.Management.Core.Tests.Model @@ -8,16 +8,16 @@ public class MultiPageEntry : IEntry { public const string ContentType = "multi_page"; - [JsonProperty(propertyName: "uid")] + [JsonPropertyName("uid")] public string Uid { get; set; } - - [JsonProperty(propertyName: "_content_type_uid")] + + [JsonPropertyName("_content_type_uid")] public string ContentTypeUid { get; set; } - - [JsonProperty(propertyName: "title")] + + [JsonPropertyName("title")] public string Title { get; set; } - - [JsonProperty(propertyName: "url")] + + [JsonPropertyName("url")] public string Url { get; set; } } } diff --git a/Contentstack.Management.Core.Tests/Model/PageJSONRTE.cs b/Contentstack.Management.Core.Tests/Model/PageJSONRTE.cs index c2cca5f..959d6c2 100644 --- a/Contentstack.Management.Core.Tests/Model/PageJSONRTE.cs +++ b/Contentstack.Management.Core.Tests/Model/PageJSONRTE.cs @@ -1,5 +1,5 @@ +using System.Text.Json.Serialization; using Contentstack.Management.Core.Models; -using Newtonsoft.Json; using Contentstack.Management.Core.Abstractions; namespace Contentstack.Management.Core.Tests.Model @@ -8,12 +8,12 @@ public partial class PageJSONRTE : IEntry { public const string ContentType = "page_json_rte"; - [JsonProperty(propertyName: "uid")] + [JsonPropertyName("uid")] public string Uid { get; set; } - [JsonProperty(propertyName: "_content_type_uid")] + [JsonPropertyName("_content_type_uid")] public string ContentTypeUid { get; set; } public string Title { get; set; } - [JsonProperty(propertyName: "rte_data")] + [JsonPropertyName("rte_data")] public Node RteData { get; set; } } -} \ No newline at end of file +} diff --git a/Contentstack.Management.Core.Tests/Model/SinglePageEntry.cs b/Contentstack.Management.Core.Tests/Model/SinglePageEntry.cs index f4d7552..82b6c6a 100644 --- a/Contentstack.Management.Core.Tests/Model/SinglePageEntry.cs +++ b/Contentstack.Management.Core.Tests/Model/SinglePageEntry.cs @@ -1,5 +1,5 @@ +using System.Text.Json.Serialization; using Contentstack.Management.Core.Models; -using Newtonsoft.Json; using Contentstack.Management.Core.Abstractions; namespace Contentstack.Management.Core.Tests.Model @@ -8,16 +8,16 @@ public class SinglePageEntry : IEntry { public const string ContentType = "single_page"; - [JsonProperty(propertyName: "uid")] + [JsonPropertyName("uid")] public string Uid { get; set; } - - [JsonProperty(propertyName: "_content_type_uid")] + + [JsonPropertyName("_content_type_uid")] public string ContentTypeUid { get; set; } - - [JsonProperty(propertyName: "title")] + + [JsonPropertyName("title")] public string Title { get; set; } - - [JsonProperty(propertyName: "url")] + + [JsonPropertyName("url")] public string Url { get; set; } } } diff --git a/Contentstack.Management.Core.Tests/Model/StackModel.cs b/Contentstack.Management.Core.Tests/Model/StackModel.cs index ce71ae7..77d0324 100644 --- a/Contentstack.Management.Core.Tests/Model/StackModel.cs +++ b/Contentstack.Management.Core.Tests/Model/StackModel.cs @@ -1,23 +1,23 @@ using System; using System.IO; -using Newtonsoft.Json; -using Newtonsoft.Json.Linq; +using System.Text.Json; +using System.Text.Json.Serialization; namespace Contentstack.Management.Core.Tests.Model { public class StackModel { - [JsonProperty("api_key")] + [JsonPropertyName("api_key")] public string APIKey { get; set; } public string Name { get; set; } public string Description { get; set; } - [JsonProperty("master_locale")] + [JsonPropertyName("master_locale")] public string MasterLocale { get; set; } - [JsonProperty("org_uid")] + [JsonPropertyName("org_uid")] public string OrgUid { get; set; } } @@ -25,11 +25,10 @@ public class StackResponse { public StackModel Stack { get; set; } - public static StackResponse getStack(JsonSerializer serializer) + public static StackResponse getStack(JsonSerializerOptions options) { string response = File.ReadAllText("./stackApiKey.txt"); - JObject jObject = JObject.Parse(response); - return jObject.ToObject(serializer); + return JsonSerializer.Deserialize(response, options); } } } diff --git a/Contentstack.Management.Core.Tests/Model/StackSettingsModel.cs b/Contentstack.Management.Core.Tests/Model/StackSettingsModel.cs index ea4294a..da9cf69 100644 --- a/Contentstack.Management.Core.Tests/Model/StackSettingsModel.cs +++ b/Contentstack.Management.Core.Tests/Model/StackSettingsModel.cs @@ -1,6 +1,6 @@ using System; +using System.Text.Json.Serialization; using Contentstack.Management.Core.Models; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Tests.Model { @@ -8,7 +8,7 @@ public class StackSettingsModel { public string Notice { get; set; } - [JsonProperty("stack_settings")] + [JsonPropertyName("stack_settings")] public StackSettings StackSettings { get; set; } } } diff --git a/Contentstack.Management.Core.Unit.Tests/Core/ContentstackClientTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/ContentstackClientTest.cs index ecb978e..7cce155 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/ContentstackClientTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/ContentstackClientTest.cs @@ -19,7 +19,7 @@ public void Initialize_Contentstack() var contentstackClient = new ContentstackClient(); Assert.IsNotNull(contentstackClient.LogManager); - Assert.IsNotNull(contentstackClient.SerializerSettings); + Assert.IsNotNull(contentstackClient.SerializerOptions); Assert.AreEqual(contentstackClient.User().GetType(), typeof(User)); Assert.AreEqual(contentstackClient.Organization().GetType(), typeof(Organization)); Assert.AreEqual(contentstackClient.Stack().GetType(), typeof(Stack)); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/ContentstackServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/ContentstackServiceTest.cs index 873e283..6abc6ba 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/ContentstackServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/ContentstackServiceTest.cs @@ -1,11 +1,11 @@ using System; using System.Collections.Generic; -using System.Globalization; using System.IO; using System.Linq; using System.Net; using System.Net.Http; using System.Text; +using System.Text.Json; using AutoFixture; using AutoFixture.AutoMoq; using Contentstack.Management.Core.Http; @@ -14,14 +14,13 @@ using Contentstack.Management.Core.Unit.Tests.Mokes; using Contentstack.Management.Core.Utils; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services { [TestClass] public class ContentstackServiceTest { - JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); [TestMethod] @@ -51,7 +50,7 @@ public void Returns_Null_Content() Assert.IsNotNull(contentstackService); Assert.IsNull(contentstackService.Content); - Assert.IsNotNull(contentstackService.Serializer); + Assert.IsNotNull(contentstackService.SerializerOptions); } [TestMethod] @@ -59,17 +58,15 @@ public void Return_Content_data() { var contentstackService = new ContentstackService(serializer); - using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture)) + using var ms = new MemoryStream(); + using (var writer = new Utf8JsonWriter(ms)) { - JsonWriter writer = new JsonTextWriter(stringWriter); writer.WriteStartObject(); - writer.WritePropertyName("user"); - writer.WriteValue("test_Mock_user"); + writer.WriteString("user", "test_Mock_user"); writer.WriteEndObject(); - - string snippet = stringWriter.ToString(); - contentstackService.ByteContent = System.Text.Encoding.UTF8.GetBytes(snippet); } + + contentstackService.ByteContent = ms.ToArray(); contentstackService.WriteContentByte(); Assert.IsNotNull(contentstackService.Content); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/CreateUpdateFolderServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/CreateUpdateFolderServiceTest.cs index e0616e6..06979c5 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/CreateUpdateFolderServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/CreateUpdateFolderServiceTest.cs @@ -5,14 +5,13 @@ using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Services.Models; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class CreateUpdateFolderServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/CreateUpdateServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/CreateUpdateServiceTest.cs index 75ec27c..097cb8a 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/CreateUpdateServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/CreateUpdateServiceTest.cs @@ -5,14 +5,13 @@ using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Services.Models; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class CreateUpdateServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/DeleteServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/DeleteServiceTest.cs index 97b9d5e..0c97ce3 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/DeleteServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/DeleteServiceTest.cs @@ -5,14 +5,13 @@ using Contentstack.Management.Core.Services.Models; using Contentstack.Management.Core.Unit.Tests.Models.ContentModel; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class DeleteServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/FetchDeleteServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/FetchDeleteServiceTest.cs index a822944..4faf68a 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/FetchDeleteServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/FetchDeleteServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Services.Models; using Contentstack.Management.Core.Utils; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class FetchDeleteServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/FetchReferencesServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/FetchReferencesServiceTest.cs index 0226f91..470888d 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/FetchReferencesServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/FetchReferencesServiceTest.cs @@ -3,13 +3,12 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.Models; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class FetchReferencesServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/LocaleServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/LocaleServiceTest.cs index 2efd969..b71788b 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/LocaleServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/LocaleServiceTest.cs @@ -5,13 +5,12 @@ using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Services.Models; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class LocaleServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/LocalizationServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/LocalizationServiceTest.cs index b2639b1..f28770c 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/LocalizationServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/LocalizationServiceTest.cs @@ -5,13 +5,12 @@ using Contentstack.Management.Core.Services.Models; using Contentstack.Management.Core.Unit.Tests.Models.ContentModel; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class LocalizationServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/PublishUnpublishServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/PublishUnpublishServiceTest.cs index 7e4dba7..224f7aa 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/PublishUnpublishServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/PublishUnpublishServiceTest.cs @@ -6,13 +6,12 @@ using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Services.Models; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class PublishUnpublishServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/UploadServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/UploadServiceTest.cs index 0756cd1..138ee97 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/UploadServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Models/UploadServiceTest.cs @@ -4,14 +4,13 @@ using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Services.Models; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Models { [TestClass] public class UploadServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); private AssetModel _assetModel; diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/GetOrganizationsTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/GetOrganizationsTest.cs index 6b9e775..00f4ad0 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/GetOrganizationsTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/GetOrganizationsTest.cs @@ -3,14 +3,13 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.Organization; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Organization { [TestClass] public class GetOrganizationsTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/OrgRolesTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/OrgRolesTest.cs index 99f124f..bb7112b 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/OrgRolesTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/OrgRolesTest.cs @@ -3,14 +3,13 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.Organization; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Organization { [TestClass] public class OrgRolesTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); [TestMethod] diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/OrganizationStackServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/OrganizationStackServiceTest.cs index c9bf080..30804ca 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/OrganizationStackServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/OrganizationStackServiceTest.cs @@ -3,14 +3,13 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.Organization; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Organization { [TestClass] public class OrganizationStackServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/ResendInvitationServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/ResendInvitationServiceTest.cs index a1b2bca..9c12449 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/ResendInvitationServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/ResendInvitationServiceTest.cs @@ -3,7 +3,6 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.Organization; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Organization { @@ -11,7 +10,7 @@ namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Organization public class ResendInvitationServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/TransferOwnershipServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/TransferOwnershipServiceTest.cs index 7b37eee..db56e60 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/TransferOwnershipServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/TransferOwnershipServiceTest.cs @@ -4,14 +4,13 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.Organization; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Organization { [TestClass] public class TransferOwnershipServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/UserInvitationServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/UserInvitationServiceTest.cs index e5c7e13..b48067a 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/UserInvitationServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Organization/UserInvitationServiceTest.cs @@ -7,14 +7,13 @@ using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Services.Organization; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Organization { [TestClass] public class UserInvitationServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/QueryServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/QueryServiceTest.cs index c28ace5..751084d 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/QueryServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/QueryServiceTest.cs @@ -13,7 +13,6 @@ using Contentstack.Management.Core.Unit.Tests.Mokes; using Contentstack.Management.Core.Utils; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services { [TestClass] diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkAddItemsServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkAddItemsServiceTest.cs index d0e230d..7718615 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkAddItemsServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkAddItemsServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Services.Stack.BulkOperation; using Contentstack.Management.Core.Services; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class BulkAddItemsServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkDeleteServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkDeleteServiceTest.cs index 11f05c1..f8ce607 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkDeleteServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkDeleteServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Services.Stack.BulkOperation; using Contentstack.Management.Core.Services; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class BulkDeleteServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); @@ -233,10 +232,7 @@ public void Should_Verify_Service_Properties_Are_Set() public void Should_Verify_Service_Can_Be_Instantiated_With_Different_Serializers() { var details = new BulkDeleteDetails(); - var customSerializer = JsonSerializer.Create(new JsonSerializerSettings - { - NullValueHandling = NullValueHandling.Ignore - }); + var customSerializer = new JsonSerializerOptions { DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull }; var service = new BulkDeleteService(customSerializer, new Management.Core.Models.Stack(null), details); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkJobStatusServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkJobStatusServiceTest.cs index 2bb416b..22b0e3d 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkJobStatusServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkJobStatusServiceTest.cs @@ -5,14 +5,13 @@ using Contentstack.Management.Core.Services.Stack.BulkOperation; using Contentstack.Management.Core.Services; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class BulkJobStatusServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); @@ -242,10 +241,7 @@ public void Should_Verify_Service_Properties_Are_Set() public void Should_Verify_Service_Can_Be_Instantiated_With_Different_Serializers() { var jobId = "test-job-id"; - var customSerializer = JsonSerializer.Create(new JsonSerializerSettings - { - NullValueHandling = NullValueHandling.Ignore - }); + var customSerializer = new JsonSerializerOptions { DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull }; var service = new BulkJobStatusService(customSerializer, new Management.Core.Models.Stack(null), jobId); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkPublishServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkPublishServiceTest.cs index 73284a2..4c76199 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkPublishServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkPublishServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Services.Stack.BulkOperation; using Contentstack.Management.Core.Services; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class BulkPublishServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); @@ -257,10 +256,7 @@ public void Should_Verify_Service_Properties_Are_Set() public void Should_Verify_Service_Can_Be_Instantiated_With_Different_Serializers() { var details = new BulkPublishDetails(); - var customSerializer = JsonSerializer.Create(new JsonSerializerSettings - { - NullValueHandling = NullValueHandling.Ignore - }); + var customSerializer = new JsonSerializerOptions { DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull }; var service = new BulkPublishService(customSerializer, new Management.Core.Models.Stack(null), details); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkReleaseItemsServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkReleaseItemsServiceTest.cs index 22dc90b..4086996 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkReleaseItemsServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkReleaseItemsServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Services.Stack.BulkOperation; using Contentstack.Management.Core.Services; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class BulkReleaseItemsServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); @@ -271,10 +270,7 @@ public void Should_Verify_Service_Properties_Are_Set() public void Should_Verify_Service_Can_Be_Instantiated_With_Different_Serializers() { var data = new BulkReleaseItemsData(); - var customSerializer = JsonSerializer.Create(new JsonSerializerSettings - { - NullValueHandling = NullValueHandling.Ignore - }); + var customSerializer = new JsonSerializerOptions { DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull }; var service = new BulkReleaseItemsService(customSerializer, new Management.Core.Models.Stack(null), data); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkUnpublishServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkUnpublishServiceTest.cs index ff9b709..bfb6a9a 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkUnpublishServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkUnpublishServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Services.Stack.BulkOperation; using Contentstack.Management.Core.Services; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class BulkUnpublishServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); @@ -257,10 +256,7 @@ public void Should_Verify_Service_Properties_Are_Set() public void Should_Verify_Service_Can_Be_Instantiated_With_Different_Serializers() { var details = new BulkPublishDetails(); - var customSerializer = JsonSerializer.Create(new JsonSerializerSettings - { - NullValueHandling = NullValueHandling.Ignore - }); + var customSerializer = new JsonSerializerOptions { DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull }; var service = new BulkUnpublishService(customSerializer, new Management.Core.Models.Stack(null), details); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkUpdateItemsServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkUpdateItemsServiceTest.cs index fc28d12..671fabf 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkUpdateItemsServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkUpdateItemsServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Services.Stack.BulkOperation; using Contentstack.Management.Core.Services; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class BulkUpdateItemsServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); @@ -281,10 +280,7 @@ public void Should_Verify_Service_Properties_Are_Set() public void Should_Verify_Service_Can_Be_Instantiated_With_Different_Serializers() { var data = new BulkAddItemsData(); - var customSerializer = JsonSerializer.Create(new JsonSerializerSettings - { - NullValueHandling = NullValueHandling.Ignore - }); + var customSerializer = new JsonSerializerOptions { DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull }; var service = new BulkUpdateItemsService(customSerializer, new Management.Core.Models.Stack(null), data); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkWorkflowUpdateServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkWorkflowUpdateServiceTest.cs index 75cc25f..f8df543 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkWorkflowUpdateServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/BulkWorkflowUpdateServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Services.Stack.BulkOperation; using Contentstack.Management.Core.Services; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class BulkWorkflowUpdateServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); @@ -223,10 +222,7 @@ public void Should_Verify_Service_Properties_Are_Set() public void Should_Verify_Service_Can_Be_Instantiated_With_Different_Serializers() { var updateBody = new BulkWorkflowUpdateBody(); - var customSerializer = JsonSerializer.Create(new JsonSerializerSettings - { - NullValueHandling = NullValueHandling.Ignore - }); + var customSerializer = new JsonSerializerOptions { DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull }; var service = new BulkWorkflowUpdateService(customSerializer, new Management.Core.Models.Stack(null), updateBody); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/FetchStackServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/FetchStackServiceTest.cs index 87d05e1..6e5ec5a 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/FetchStackServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/FetchStackServiceTest.cs @@ -4,7 +4,6 @@ using Contentstack.Management.Core.Services.Stack; using Contentstack.Management.Core.Models; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; using Contentstack.Management.Core.Queryable; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack @@ -12,7 +11,7 @@ namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack [TestClass] public class FetchStackServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackCreateUpdateServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackCreateUpdateServiceTest.cs index 163e2c3..680c42d 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackCreateUpdateServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackCreateUpdateServiceTest.cs @@ -4,14 +4,13 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.Stack; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class StackCreateUpdateServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackOwnershipServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackOwnershipServiceTest.cs index a14dc89..2f8cba3 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackOwnershipServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackOwnershipServiceTest.cs @@ -4,14 +4,13 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.Stack; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class StackOwnershipServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackSettingsServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackSettingsServiceTest.cs index 931148a..8a9fff4 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackSettingsServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackSettingsServiceTest.cs @@ -5,14 +5,13 @@ using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Services.Stack; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class StackSettingsServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); @@ -55,7 +54,7 @@ public void Should_Return_Stack_Settings_Content() Assert.AreEqual("POST", service.HttpMethod); Assert.AreEqual("stacks/settings", service.ResourcePath); Assert.AreEqual(apiKey, service.Headers["api_key"]); - var json = JsonConvert.SerializeObject(settings); + var json = JsonSerializer.Serialize(settings); Assert.AreEqual($"{{\"stack_settings\":{json.ToString()}}}", Encoding.Default.GetString(service.ByteContent)); } diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackShareServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackShareServiceTest.cs index b44420b..92250f7 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackShareServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/Stack/StackShareServiceTest.cs @@ -6,14 +6,13 @@ using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Services.Stack; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.Stack { [TestClass] public class StackShareServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/ForgotPasswordServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/ForgotPasswordServiceTest.cs index 93ca651..e120ceb 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/ForgotPasswordServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/ForgotPasswordServiceTest.cs @@ -3,14 +3,13 @@ using AutoFixture; using Contentstack.Management.Core.Services.User; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.User { [TestClass] public class ForgotPasswordServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture(); [TestMethod] diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/GetLoggedinUserTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/GetLoggedinUserTest.cs index ce89cd5..d41496e 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/GetLoggedinUserTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/GetLoggedinUserTest.cs @@ -1,14 +1,13 @@ using System; using Contentstack.Management.Core.Services.User; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.User { [TestClass] public class GetLoggedinUserTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); [TestMethod] public void Should_Throw_On_Null_Serializer() diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/LoginServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/LoginServiceTest.cs index ed7dfdd..dae9dad 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/LoginServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/LoginServiceTest.cs @@ -6,7 +6,6 @@ using Contentstack.Management.Core.Services.User; using Contentstack.Management.Core.Unit.Tests.Mokes; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.User { @@ -14,7 +13,7 @@ namespace Contentstack.Management.Core.Unit.Tests.Core.Services.User public class LoginServiceTest { ICredentials credentials = new NetworkCredential("name", "password"); - JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); [TestMethod] public void Should_Not_Allow_Null_serializer() diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/LogoutServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/LogoutServiceTest.cs index 8d1dbc7..a013bf5 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/LogoutServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/LogoutServiceTest.cs @@ -3,14 +3,13 @@ using Contentstack.Management.Core.Services.User; using Contentstack.Management.Core.Unit.Tests.Mokes; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.User { [TestClass] public class LogoutServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly string _authtoken = "authtoken"; private readonly IFixture _fixture = new Fixture(); diff --git a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/ResetPasswordServiceTest.cs b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/ResetPasswordServiceTest.cs index 57f3580..72c5331 100644 --- a/Contentstack.Management.Core.Unit.Tests/Core/Services/User/ResetPasswordServiceTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Core/Services/User/ResetPasswordServiceTest.cs @@ -4,14 +4,13 @@ using AutoFixture.AutoMoq; using Contentstack.Management.Core.Services.User; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Core.Services.User { [TestClass] public class ResetPasswordServiceTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); + private JsonSerializerOptions serializer = TestJsonSerializerOptions.CreateDefault(); private readonly IFixture _fixture = new Fixture() .Customize(new AutoMoqCustomization()); diff --git a/Contentstack.Management.Core.Unit.Tests/GlobalUsings.cs b/Contentstack.Management.Core.Unit.Tests/GlobalUsings.cs new file mode 100644 index 0000000..eafff39 --- /dev/null +++ b/Contentstack.Management.Core.Unit.Tests/GlobalUsings.cs @@ -0,0 +1,3 @@ +global using System.Text.Json; +global using System.Text.Json.Serialization; +global using static Contentstack.Management.Core.Unit.Tests.TestJsonSerializerOptions; diff --git a/Contentstack.Management.Core.Unit.Tests/Http/ContentstackHttpRequestTest.cs b/Contentstack.Management.Core.Unit.Tests/Http/ContentstackHttpRequestTest.cs index ecea427..d028269 100644 --- a/Contentstack.Management.Core.Unit.Tests/Http/ContentstackHttpRequestTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Http/ContentstackHttpRequestTest.cs @@ -1,9 +1,9 @@ using Moq; -using System; +using System; using System.Net; using System.Text; using AutoFixture; -using System.Net.Http; +using System.Net.Http; using AutoFixture.AutoMoq; using System.Collections.Generic; using Contentstack.Management.Core.Http; @@ -28,7 +28,7 @@ public class ContentstackHttpRequestTest [TestInitialize] public void Initialize() { - _httpRequest = new ContentstackHttpRequest(new System.Net.Http.HttpClient(), Utils.Utilities.GetJsonSerializer()); + _httpRequest = new ContentstackHttpRequest(new System.Net.Http.HttpClient(), Utils.Utilities.GetJsonSerializerOptions()); } @@ -129,7 +129,7 @@ public async Task Return_OK_Response_On_Request_SuccessAsync() ItExpr.IsAny()) .ReturnsAsync(response); var httpClient = new HttpClient(handlerMock.Object); - var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializer()); + var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializerOptions()); HttpRequest.RequestUri = new Uri("https://localhost.com"); var httpResponse = HttpRequest.GetResponse(); @@ -156,7 +156,7 @@ public void Return_UnprocessableEntity_Response_On_Request_FailuerAsync() ItExpr.IsAny()) .ReturnsAsync(response); var httpClient = new HttpClient(handlerMock.Object); - var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializer()); + var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializerOptions()); HttpRequest.RequestUri = new Uri("https://localhost.com"); try { @@ -191,7 +191,7 @@ public void Return_UnprocessableEntity_Response_On_Request_Fail_400() ItExpr.IsAny()) .ReturnsAsync(response); var httpClient = new HttpClient(handlerMock.Object); - var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializer()); + var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializerOptions()); HttpRequest.RequestUri = new Uri("https://localhost.com"); try { @@ -225,7 +225,7 @@ public void Return_UnprocessableEntity_Response_On_Request_Fail_304() ItExpr.IsAny()) .ReturnsAsync(response); var httpClient = new HttpClient(handlerMock.Object); - var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializer()); + var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializerOptions()); HttpRequest.RequestUri = new Uri("https://localhost.com"); try { @@ -258,7 +258,7 @@ public void Return_Exception_Response_On_Request_Exception() .Throws(new HttpRequestException(response)); var httpClient = new HttpClient(handlerMock.Object); - var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializer()); + var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializerOptions()); HttpRequest.RequestUri = new Uri("https://localhost.com"); try { @@ -292,7 +292,7 @@ public void Return_Inner_Exception_Response_On_Request_Exception() .Throws(new HttpRequestException("Outer Exception" ,new IOException(response))); var httpClient = new HttpClient(handlerMock.Object); - var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializer()); + var HttpRequest = new ContentstackHttpRequest(httpClient, Utils.Utilities.GetJsonSerializerOptions()); HttpRequest.RequestUri = new Uri("https://localhost.com"); try { diff --git a/Contentstack.Management.Core.Unit.Tests/Http/ContentstackHttpResponseTest.cs b/Contentstack.Management.Core.Unit.Tests/Http/ContentstackHttpResponseTest.cs index 36c0cce..5698676 100644 --- a/Contentstack.Management.Core.Unit.Tests/Http/ContentstackHttpResponseTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Http/ContentstackHttpResponseTest.cs @@ -75,7 +75,7 @@ public void Should_Throw_Object_Disposed_Exception_On_Object_Dispose() contentstackHttpResponse.Dispose(); Assert.ThrowsException(() => contentstackHttpResponse.OpenResponse()); - Assert.ThrowsException(() => contentstackHttpResponse.OpenJObjectResponse()); + Assert.ThrowsException(() => contentstackHttpResponse.OpenJsonObjectResponse()); Assert.ThrowsException(() => contentstackHttpResponse.OpenTResponse()); contentstackHttpResponse.Dispose(); diff --git a/Contentstack.Management.Core.Unit.Tests/Models/AssetTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/AssetTest.cs index 963ec0d..509b35a 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/AssetTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/AssetTest.cs @@ -1,5 +1,6 @@ using System; using AutoFixture; +using System.Text.Json.Serialization; using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Queryable; using Contentstack.Management.Core.Unit.Tests.Mokes; @@ -22,6 +23,9 @@ public void initialize() client.ContentstackPipeline.ReplaceHandler(new MockHttpHandler(_contentstackResponse)); client.contentstackOptions.Authtoken = _fixture.Create(); _stack = new Stack(client, _fixture.Create()); + + // Configure System.Text.Json options + client.SerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull; } [TestMethod] @@ -66,7 +70,7 @@ public void Should_Create_Asset() ContentstackResponse response = _stack.Asset().Create(_assetModel); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -75,7 +79,7 @@ public async System.Threading.Tasks.Task Should_Create_Asset_Async() ContentstackResponse response = await _stack.Asset().CreateAsync(_assetModel); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -87,7 +91,7 @@ public void Should_Query_Asset() ContentstackResponse response = _stack.Asset().Query().Find(collection); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -96,7 +100,7 @@ public async System.Threading.Tasks.Task Should_Query_Asset_Async() ContentstackResponse response = await _stack.Asset().Query().FindAsync(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -105,7 +109,7 @@ public void Should_Fetch_Asset() ContentstackResponse response = _stack.Asset(_fixture.Create()).Fetch(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -114,7 +118,7 @@ public async System.Threading.Tasks.Task Should_Find_Asset_Async() ContentstackResponse response = await _stack.Asset(_fixture.Create()).FetchAsync(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -124,7 +128,7 @@ public void Should_Update_Asset() ContentstackResponse response = _stack.Asset(_fixture.Create()).Update(_assetModel); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -133,7 +137,7 @@ public async System.Threading.Tasks.Task Should_Update_Asset_Async() ContentstackResponse response = await _stack.Asset(_fixture.Create()).UpdateAsync(_assetModel); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -142,7 +146,7 @@ public void Should_Delete_Asset() ContentstackResponse response = _stack.Asset(_fixture.Create()).Delete(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -151,7 +155,7 @@ public async System.Threading.Tasks.Task Should_Delete_Asset_Async() ContentstackResponse response = await _stack.Asset(_fixture.Create()).DeleteAsync(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -160,7 +164,7 @@ public void Should_Publish_Asset() ContentstackResponse response = _stack.Asset(_fixture.Create()).Publish(_fixture.Create()); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -169,7 +173,7 @@ public async System.Threading.Tasks.Task Should_Publish_Asset_Async() ContentstackResponse response = await _stack.Asset(_fixture.Create()).PublishAsync(_fixture.Create()); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] public void Should_Unpublish_Asset() @@ -177,7 +181,7 @@ public void Should_Unpublish_Asset() ContentstackResponse response = _stack.Asset(_fixture.Create()).Unpublish(_fixture.Create()); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -186,7 +190,7 @@ public async System.Threading.Tasks.Task Should_Unpublish_Asset_Async() ContentstackResponse response = await _stack.Asset(_fixture.Create()).UnpublishAsync(_fixture.Create()); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -195,7 +199,7 @@ public void Should_Get_References_Asset() ContentstackResponse response = _stack.Asset(_fixture.Create()).References(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -204,7 +208,7 @@ public async System.Threading.Tasks.Task Should_Get_References_Asset_Async() ContentstackResponse response = await _stack.Asset(_fixture.Create()).ReferencesAsync(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } } } diff --git a/Contentstack.Management.Core.Unit.Tests/Models/AuditLogTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/AuditLogTest.cs index d09af8b..7357e68 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/AuditLogTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/AuditLogTest.cs @@ -52,7 +52,7 @@ public void Should_Fetch_AuditLog() ContentstackResponse response = _stack.AuditLog(_fixture.Create()).Fetch(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -61,7 +61,7 @@ public async System.Threading.Tasks.Task Should_Fetch_AuditLog_Async() ContentstackResponse response = await _stack.AuditLog(_fixture.Create()).FetchAsync(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -70,7 +70,7 @@ public void Should_Find_AuditLog() ContentstackResponse response = _stack.AuditLog().FindAll(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -79,7 +79,7 @@ public async System.Threading.Tasks.Task Should_Find_AuditLog_Async() ContentstackResponse response = await _stack.AuditLog().FindAllAsync(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } } diff --git a/Contentstack.Management.Core.Unit.Tests/Models/BaseModelTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/BaseModelTest.cs index c9e44d0..59fa0a2 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/BaseModelTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/BaseModelTest.cs @@ -1,4 +1,5 @@ -using System; +using System; +using System.Threading.Tasks; using AutoFixture; using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Unit.Tests.Mokes; @@ -36,28 +37,28 @@ public void Should_Throw_on_FieldName_Empty() } [TestMethod] - public void Initialize_ContentType() + public async Task Initialize_ContentType() { BaseModel baseModel = new BaseModel(_stack, _fixture.Create()); Assert.IsNull(baseModel.Uid); Assert.ThrowsException(() => baseModel.Fetch()); - Assert.ThrowsExceptionAsync(() => baseModel.FetchAsync()); + await Assert.ThrowsExceptionAsync(() => baseModel.FetchAsync()); Assert.ThrowsException(() => baseModel.Update(new ContentModelling())); - Assert.ThrowsExceptionAsync(() => baseModel.UpdateAsync(new ContentModelling())); + await Assert.ThrowsExceptionAsync(() => baseModel.UpdateAsync(new ContentModelling())); Assert.ThrowsException(() => baseModel.Delete()); - Assert.ThrowsExceptionAsync(() => baseModel.DeleteAsync()); + await Assert.ThrowsExceptionAsync(() => baseModel.DeleteAsync()); } [TestMethod] - public void Initialize_BaseModel_With_Uid() + public async Task Initialize_BaseModel_With_Uid() { string uid = _fixture.Create(); BaseModel baseModel = new BaseModel(_stack, _fixture.Create(), uid); Assert.AreEqual(uid, baseModel.Uid); Assert.ThrowsException(() => baseModel.Create(new ContentModelling())); - Assert.ThrowsExceptionAsync(() => baseModel.CreateAsync(new ContentModelling())); + await Assert.ThrowsExceptionAsync(() => baseModel.CreateAsync(new ContentModelling())); } [TestMethod] @@ -69,7 +70,7 @@ public void Should_Return_Mock_Response_On_Create() ContentstackResponse response = baseModel.Create(new ContentModelling()); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -81,7 +82,7 @@ public async System.Threading.Tasks.Task Should_Return_Mock_Response_On_CreateAs ContentstackResponse response = await baseModel.CreateAsync(new ContentModelling()); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -93,7 +94,7 @@ public void Should_Return_Mock_Response_On_Update() ContentstackResponse response = baseModel.Update(new ContentModelling()); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -105,7 +106,7 @@ public async System.Threading.Tasks.Task Should_Return_Mock_Response_On_UpdateAs ContentstackResponse response = await baseModel.UpdateAsync(new ContentModelling()); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -117,7 +118,7 @@ public void Should_Return_Mock_Response_On_Fetch() ContentstackResponse response = baseModel.Fetch(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -129,7 +130,7 @@ public async System.Threading.Tasks.Task Should_Return_Mock_Response_On_FetchAsy ContentstackResponse response = await baseModel.FetchAsync(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -141,7 +142,7 @@ public void Should_Return_Mock_Response_On_Delete() ContentstackResponse response = baseModel.Delete(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } [TestMethod] @@ -153,7 +154,7 @@ public async System.Threading.Tasks.Task Should_Return_Mock_Response_On_DeleteAs ContentstackResponse response = await baseModel.DeleteAsync(); Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse()); - Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString()); + Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString()); } } } diff --git a/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationModelsTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationModelsTest.cs index 0e5a8b5..e7bb875 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationModelsTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationModelsTest.cs @@ -1,7 +1,6 @@ using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; using Contentstack.Management.Core.Models; namespace Contentstack.Management.Core.Unit.Tests.Models.BulkOperation @@ -42,8 +41,8 @@ public void BulkPublishDetails_Serialization_Test() }; - var json = JsonConvert.SerializeObject(details); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(details); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Entries.Count); @@ -74,8 +73,8 @@ public void BulkPublishEntry_WithContentType_Serialization_Test() }; - var json = JsonConvert.SerializeObject(entry); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(entry); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual("entry_uid", deserialized.Uid); @@ -113,8 +112,8 @@ public void BulkDeleteDetails_Serialization_Test() }; - var json = JsonConvert.SerializeObject(details); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(details); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Entries.Count); @@ -168,8 +167,8 @@ public void BulkWorkflowUpdateBody_Serialization_Test() }; - var json = JsonConvert.SerializeObject(updateBody); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(updateBody); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(1, deserialized.Entries.Count); @@ -220,8 +219,8 @@ public void BulkAddItemsData_Serialization_Test() }; - var json = JsonConvert.SerializeObject(data); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(data); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Items.Count); @@ -242,8 +241,8 @@ public void BulkPublishDetails_EmptyCollections_Test() }; - var json = JsonConvert.SerializeObject(details); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(details); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); // Collections may be null after deserialization due to ShouldSerialize methods @@ -285,8 +284,8 @@ public void BulkPublishDetails_WithRulesAndScheduling_Test() }; - var json = JsonConvert.SerializeObject(details); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(details); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(1, deserialized.Entries.Count); @@ -317,8 +316,8 @@ public void BulkWorkflowStage_EmptyCollections_Test() }; - var json = JsonConvert.SerializeObject(workflowStage); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(workflowStage); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual("test_uid", deserialized.Uid); @@ -342,8 +341,8 @@ public void BulkPublishEntry_NullValues_Test() }; - var json = JsonConvert.SerializeObject(entry); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(entry); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual("entry_uid", deserialized.Uid); diff --git a/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationsUnitTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationsUnitTest.cs index da37367..2b21878 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationsUnitTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationsUnitTest.cs @@ -1,7 +1,6 @@ using Microsoft.VisualStudio.TestTools.UnitTesting; using Contentstack.Management.Core.Models; using System.Collections.Generic; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Models.BulkOperation { @@ -32,7 +31,7 @@ public void Test001_BulkReleaseItemsData_Serialization() }; - var json = JsonConvert.SerializeObject(releaseData); + var json = JsonSerializer.Serialize(releaseData); Assert.IsNotNull(json); Assert.IsTrue(json.Contains("release")); @@ -60,7 +59,7 @@ public void Test002_BulkReleaseItem_Serialization() }; - var json = JsonConvert.SerializeObject(item); + var json = JsonSerializer.Serialize(item); Assert.IsNotNull(json); Assert.IsTrue(json.Contains("content_type_uid")); @@ -91,7 +90,7 @@ public void Test003_BulkReleaseItemsData_Deserialization() }"; - var releaseData = JsonConvert.DeserializeObject(json); + var releaseData = JsonSerializer.Deserialize(json); Assert.IsNotNull(releaseData); Assert.AreEqual("release_uid", releaseData.Release); @@ -120,7 +119,7 @@ public void Test004_BulkReleaseItem_Deserialization() }"; - var item = JsonConvert.DeserializeObject(json); + var item = JsonSerializer.Deserialize(json); Assert.IsNotNull(item); Assert.AreEqual("ct_1", item.ContentTypeUid); @@ -141,7 +140,7 @@ public void Test005_BulkReleaseItemsData_Empty_Collections() }; - var json = JsonConvert.SerializeObject(releaseData); + var json = JsonSerializer.Serialize(releaseData); Assert.IsNotNull(json); Assert.IsNotNull(releaseData.Locale); @@ -182,8 +181,8 @@ public void Test006_BulkReleaseItemsData_Multiple_Items() }; - var json = JsonConvert.SerializeObject(releaseData); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(releaseData); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Items.Count); @@ -217,8 +216,8 @@ public void Test007_BulkReleaseItemsData_Different_Actions() }; - var publishJson = JsonConvert.SerializeObject(publishData); - var unpublishJson = JsonConvert.SerializeObject(unpublishData); + var publishJson = JsonSerializer.Serialize(publishData); + var unpublishJson = JsonSerializer.Serialize(unpublishData); Assert.IsTrue(publishJson.Contains("publish")); Assert.IsTrue(publishJson.Contains("true")); @@ -253,7 +252,7 @@ public void Test008_BulkPublishDetails_Serialization() }; - var json = JsonConvert.SerializeObject(publishDetails); + var json = JsonSerializer.Serialize(publishDetails); Assert.IsNotNull(json); Assert.IsTrue(json.Contains("entries")); @@ -288,7 +287,7 @@ public void Test009_BulkPublishDetails_Deserialization() }"; - var publishDetails = JsonConvert.DeserializeObject(json); + var publishDetails = JsonSerializer.Deserialize(json); Assert.IsNotNull(publishDetails); Assert.AreEqual(1, publishDetails.Entries.Count); @@ -319,7 +318,7 @@ public void Test010_BulkPublishEntry_Serialization() }; - var json = JsonConvert.SerializeObject(entry); + var json = JsonSerializer.Serialize(entry); Assert.IsNotNull(json); Assert.IsTrue(json.Contains("uid")); @@ -338,7 +337,7 @@ public void Test011_BulkPublishRules_Serialization() }; - var json = JsonConvert.SerializeObject(rules); + var json = JsonSerializer.Serialize(rules); Assert.IsNotNull(json); Assert.IsTrue(json.Contains("approvals")); @@ -354,7 +353,7 @@ public void Test012_BulkPublishRules_Deserialization() }"; - var rules = JsonConvert.DeserializeObject(json); + var rules = JsonSerializer.Deserialize(json); Assert.IsNotNull(rules); Assert.AreEqual("false", rules.Approvals); @@ -396,8 +395,8 @@ public void Test013_BulkPublishDetails_Multiple_Entries() }; - var json = JsonConvert.SerializeObject(publishDetails); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(publishDetails); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(3, deserialized.Entries.Count); @@ -434,8 +433,8 @@ public void Test014_BulkPublishDetails_With_Assets() }; - var json = JsonConvert.SerializeObject(publishDetails); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(publishDetails); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(1, deserialized.Entries.Count); @@ -453,7 +452,7 @@ public void Test015_BulkPublishAsset_Serialization() }; - var json = JsonConvert.SerializeObject(asset); + var json = JsonSerializer.Serialize(asset); Assert.IsNotNull(json); Assert.IsTrue(json.Contains("uid")); @@ -471,8 +470,8 @@ public void Test016_BulkPublishDetails_Empty_Collections() }; - var json = JsonConvert.SerializeObject(publishDetails); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(publishDetails); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); // Collections may be null after deserialization due to ShouldSerialize methods @@ -508,7 +507,7 @@ public void Test017_BulkReleaseItemsData_Null_Values() }; - var json = JsonConvert.SerializeObject(releaseData); + var json = JsonSerializer.Serialize(releaseData); Assert.IsNotNull(json); // Should handle null values gracefully @@ -534,7 +533,7 @@ public void Test018_BulkPublishDetails_Null_Values() }; - var json = JsonConvert.SerializeObject(publishDetails); + var json = JsonSerializer.Serialize(publishDetails); Assert.IsNotNull(json); // Should handle null values gracefully @@ -579,8 +578,8 @@ public void Test019_BulkReleaseItemsData_Complex_Scenario() }; - var json = JsonConvert.SerializeObject(releaseData); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(releaseData); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(3, deserialized.Locale.Count); @@ -631,8 +630,8 @@ public void Test020_BulkPublishDetails_Complex_Scenario() }; - var json = JsonConvert.SerializeObject(publishDetails); - var deserialized = JsonConvert.DeserializeObject(json); + var json = JsonSerializer.Serialize(publishDetails); + var deserialized = JsonSerializer.Deserialize(json); Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Entries.Count); diff --git a/Contentstack.Management.Core.Unit.Tests/Models/BulkReleaseItemsTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/BulkReleaseItemsTest.cs index f1987f8..a289a0a 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/BulkReleaseItemsTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/BulkReleaseItemsTest.cs @@ -1,7 +1,6 @@ using Microsoft.VisualStudio.TestTools.UnitTesting; using Contentstack.Management.Core.Models; using System.Collections.Generic; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Models { @@ -32,7 +31,7 @@ public void Test001_BulkReleaseItemsData_Serialization() }; - var json = JsonConvert.SerializeObject(releaseData); + var json = JsonSerializer.Serialize(releaseData); Assert.IsNotNull(json); Assert.IsTrue(json.Contains("release")); @@ -60,7 +59,7 @@ public void Test002_BulkReleaseItem_Serialization() }; - var json = JsonConvert.SerializeObject(item); + var json = JsonSerializer.Serialize(item); Assert.IsNotNull(json); Assert.IsTrue(json.Contains("content_type_uid")); @@ -91,7 +90,7 @@ public void Test003_BulkReleaseItemsData_Deserialization() }"; - var releaseData = JsonConvert.DeserializeObject(json); + var releaseData = JsonSerializer.Deserialize(json); Assert.IsNotNull(releaseData); Assert.AreEqual("release_uid", releaseData.Release); @@ -120,7 +119,7 @@ public void Test004_BulkReleaseItem_Deserialization() }"; - var item = JsonConvert.DeserializeObject(json); + var item = JsonSerializer.Deserialize(json); Assert.IsNotNull(item); Assert.AreEqual("ct_1", item.ContentTypeUid); @@ -141,7 +140,7 @@ public void Test005_BulkReleaseItemsData_Empty_Collections() }; - var json = JsonConvert.SerializeObject(releaseData); + var json = JsonSerializer.Serialize(releaseData); Assert.IsNotNull(json); Assert.IsNotNull(releaseData.Locale); diff --git a/Contentstack.Management.Core.Unit.Tests/Models/ContentModel/ContentModellingTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/ContentModel/ContentModellingTest.cs index 64aeb34..72586e7 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/ContentModel/ContentModellingTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/ContentModel/ContentModellingTest.cs @@ -1,22 +1,18 @@ -using System; -using System.Collections.Generic; -using System.Globalization; -using System.IO; +using System.Collections.Generic; using AutoFixture; using AutoFixture.AutoMoq; +using Contentstack.Management.Core; using Contentstack.Management.Core.Models; using Contentstack.Management.Core.Models.Fields; using Microsoft.VisualStudio.TestTools.UnitTesting; -using Newtonsoft.Json; namespace Contentstack.Management.Core.Unit.Tests.Models.ContentModel { [TestClass] public class ContentModellingTest { - private JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()); private readonly IFixture _fixture = new Fixture() - .Customize(new AutoMoqCustomization()); + .Customize(new AutoMoqCustomization()); [TestMethod] public void Initialize_ContentModel() @@ -30,14 +26,9 @@ public void Initialize_ContentModel() Options = _fixture.Create