From 123cc7ee268aba296762236bb5a1ff1aebdff046 Mon Sep 17 00:00:00 2001 From: raj pandey Date: Thu, 17 Jul 2025 13:03:11 +0530 Subject: [PATCH 1/2] Feat: Added Support for Nested Global Field and Unit and integration Test cases --- .../Contentstack012_NestedGlobalFieldTest.cs | 264 +++++++++++ .../Mock/nested_gf.json | 48 ++ .../BulkOperation/BulkOperationModelsTest.cs | 45 +- .../BulkOperation/BulkOperationsUnitTest.cs | 98 ++-- .../Models/BulkReleaseItemsTest.cs | 25 +- .../ContentModellingNestedGlobalFieldTest.cs | 363 ++++++++++++++ .../GlobalFieldReferenceSerializationTest.cs | 277 +++++++++++ .../Models/Fields/GlobalFieldReferenceTest.cs | 125 +++++ .../GlobalFieldReferenceValidationTest.cs | 441 ++++++++++++++++++ .../GlobalFieldRefsSerializationTest.cs | 317 +++++++++++++ .../Models/GlobalFieldRefsTest.cs | 127 +++++ .../Services/BulkOperationServicesTest.cs | 91 ++-- .../Models/ContentModelling.cs | 6 + .../Models/Fields/GlobalFieldReference.cs | 42 ++ .../Models/GlobalFieldRefs.cs | 36 ++ 15 files changed, 2149 insertions(+), 156 deletions(-) create mode 100644 Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs create mode 100644 Contentstack.Management.Core.Tests/Mock/nested_gf.json create mode 100644 Contentstack.Management.Core.Unit.Tests/Models/ContentModellingNestedGlobalFieldTest.cs create mode 100644 Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceSerializationTest.cs create mode 100644 Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceTest.cs create mode 100644 Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceValidationTest.cs create mode 100644 Contentstack.Management.Core.Unit.Tests/Models/GlobalFieldRefsSerializationTest.cs create mode 100644 Contentstack.Management.Core.Unit.Tests/Models/GlobalFieldRefsTest.cs create mode 100644 Contentstack.Management.Core/Models/Fields/GlobalFieldReference.cs create mode 100644 Contentstack.Management.Core/Models/GlobalFieldRefs.cs diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs new file mode 100644 index 0000000..a2efac1 --- /dev/null +++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack012_NestedGlobalFieldTest.cs @@ -0,0 +1,264 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Threading.Tasks; +using AutoFixture; +using Contentstack.Management.Core.Models; +using Contentstack.Management.Core.Models.Fields; +using Contentstack.Management.Core.Queryable; +using Contentstack.Management.Core.Tests.Model; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Contentstack.Management.Core.Tests.IntegrationTest +{ + [TestClass] + public class Contentstack008_NestedGlobalFieldTest + { + private Stack _stack; + + [TestInitialize] + public void Initialize() + { + StackResponse response = StackResponse.getStack(Contentstack.Client.serializer); + _stack = Contentstack.Client.Stack(response.Stack.APIKey); + } + + private ContentModelling CreateReferencedGlobalFieldModel() + { + return new ContentModelling + { + Title = "Referenced Global Field", + Uid = "referenced_global_field", + Description = "A global field that will be referenced by another global field", + Schema = new List + { + new TextboxField + { + DisplayName = "Title", + Uid = "title", + DataType = "text", + Mandatory = true, + Unique = true, + FieldMetadata = new FieldMetadata + { + Default = "true" + } + }, + new TextboxField + { + DisplayName = "Description", + Uid = "description", + DataType = "text", + Mandatory = false, + FieldMetadata = new FieldMetadata + { + Description = "A description field" + } + } + } + }; + } + + private ContentModelling CreateNestedGlobalFieldModel() + { + return new ContentModelling + { + Title = "Nested Global Field Test", + Uid = "nested_global_field_test", + Description = "Test nested global field for .NET SDK", + Schema = new List + { + new TextboxField + { + DisplayName = "Single Line Textbox", + Uid = "single_line", + DataType = "text", + Mandatory = false, + Multiple = false, + Unique = false, + FieldMetadata = new FieldMetadata + { + Description = "", + DefaultValue = "", + Version = 3 + } + }, + new GlobalFieldReference + { + DisplayName = "Global Field Reference", + Uid = "global_field_reference", + DataType = "global_field", + ReferenceTo = "referenced_global_field", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false, + FieldMetadata = new FieldMetadata + { + Description = "Reference to another global field" + } + } + }, + GlobalFieldRefs = new List + { + new GlobalFieldRefs + { + Uid = "referenced_global_field", + OccurrenceCount = 1, + IsChild = true, + Paths = new List { "schema.1" } + } + } + }; + } + + [TestMethod] + [DoNotParallelize] + public void Test001_Should_Create_Referenced_Global_Field() + { + var referencedGlobalFieldModel = CreateReferencedGlobalFieldModel(); + ContentstackResponse response = _stack.GlobalField().Create(referencedGlobalFieldModel); + GlobalFieldModel globalField = response.OpenTResponse(); + + Assert.IsNotNull(response); + Assert.IsNotNull(globalField); + Assert.IsNotNull(globalField.Modelling); + Assert.AreEqual(referencedGlobalFieldModel.Title, globalField.Modelling.Title); + Assert.AreEqual(referencedGlobalFieldModel.Uid, globalField.Modelling.Uid); + Assert.AreEqual(referencedGlobalFieldModel.Schema.Count, globalField.Modelling.Schema.Count); + } + + [TestMethod] + [DoNotParallelize] + public void Test002_Should_Create_Nested_Global_Field() + { + var nestedGlobalFieldModel = CreateNestedGlobalFieldModel(); + ContentstackResponse response = _stack.GlobalField().Create(nestedGlobalFieldModel); + GlobalFieldModel globalField = response.OpenTResponse(); + + Assert.IsNotNull(response); + Assert.IsNotNull(globalField); + Assert.IsNotNull(globalField.Modelling); + Assert.AreEqual(nestedGlobalFieldModel.Title, globalField.Modelling.Title); + Assert.AreEqual(nestedGlobalFieldModel.Uid, globalField.Modelling.Uid); + Assert.AreEqual(nestedGlobalFieldModel.Schema.Count, globalField.Modelling.Schema.Count); + + } + + [TestMethod] + [DoNotParallelize] + public void Test003_Should_Fetch_Nested_Global_Field() + { + + ContentstackResponse response = _stack.GlobalField("nested_global_field_test").Fetch(); + GlobalFieldModel globalField = response.OpenTResponse(); + + Assert.IsNotNull(response); + Assert.IsNotNull(globalField); + Assert.IsNotNull(globalField.Modelling); + Assert.AreEqual("nested_global_field_test", globalField.Modelling.Uid); + + Assert.IsTrue(globalField.Modelling.Schema.Count >= 2); + } + + [TestMethod] + [DoNotParallelize] + public async Task Test004_Should_Fetch_Async_Nested_Global_Field() + { + + ContentstackResponse response = await _stack.GlobalField("nested_global_field_test").FetchAsync(); + GlobalFieldModel globalField = response.OpenTResponse(); + + Assert.IsNotNull(response); + Assert.IsNotNull(globalField); + Assert.IsNotNull(globalField.Modelling); + Assert.AreEqual("nested_global_field_test", globalField.Modelling.Uid); + } + + [TestMethod] + [DoNotParallelize] + public void Test005_Should_Update_Nested_Global_Field() + { + var updateModel = new ContentModelling + { + Title = "Updated Nested Global Field", + Uid = "nested_global_field_test", + Description = "Updated description for nested global field", + Schema = CreateNestedGlobalFieldModel().Schema, + GlobalFieldRefs = CreateNestedGlobalFieldModel().GlobalFieldRefs + }; + + ContentstackResponse response = _stack.GlobalField("nested_global_field_test").Update(updateModel); + GlobalFieldModel globalField = response.OpenTResponse(); + + Assert.IsNotNull(response); + Assert.IsNotNull(globalField); + Assert.IsNotNull(globalField.Modelling); + Assert.AreEqual(updateModel.Title, globalField.Modelling.Title); + Assert.AreEqual("nested_global_field_test", globalField.Modelling.Uid); + } + + [TestMethod] + [DoNotParallelize] + public async Task Test006_Should_Update_Async_Nested_Global_Field() + { + var updateModel = new ContentModelling + { + Title = "Updated Async Nested Global Field", + Uid = "nested_global_field_test", + Description = "Updated async description for nested global field", + Schema = CreateNestedGlobalFieldModel().Schema, + GlobalFieldRefs = CreateNestedGlobalFieldModel().GlobalFieldRefs + }; + + ContentstackResponse response = await _stack.GlobalField("nested_global_field_test").UpdateAsync(updateModel); + GlobalFieldModel globalField = response.OpenTResponse(); + + Assert.IsNotNull(response); + Assert.IsNotNull(globalField); + Assert.IsNotNull(globalField.Modelling); + Assert.AreEqual(updateModel.Title, globalField.Modelling.Title); + Assert.AreEqual("nested_global_field_test", globalField.Modelling.Uid); + } + + [TestMethod] + [DoNotParallelize] + public void Test007_Should_Query_Nested_Global_Fields() + { + + ContentstackResponse response = _stack.GlobalField().Query().Find(); + GlobalFieldsModel globalFields = response.OpenTResponse(); + + Assert.IsNotNull(response); + Assert.IsNotNull(globalFields); + Assert.IsNotNull(globalFields.Modellings); + Assert.IsTrue(globalFields.Modellings.Count >= 1); + + var nestedGlobalField = globalFields.Modellings.Find(gf => gf.Uid == "nested_global_field_test"); + Assert.IsNotNull(nestedGlobalField); + Assert.AreEqual("nested_global_field_test", nestedGlobalField.Uid); + } + + [TestMethod] + [DoNotParallelize] + public void Test009_Should_Delete_Referenced_Global_Field() + { + // This has been used to avoid tthe confirmation prompt during deletion in case the global field is referenced + var parameters = new ParameterCollection(); + parameters.Add("force", "true"); + ContentstackResponse response = _stack.GlobalField("referenced_global_field").Delete(parameters); + + Assert.IsNotNull(response); + } + + [TestMethod] + [DoNotParallelize] + public void Test008_Should_Delete_Nested_Global_Field() + { + ContentstackResponse response = _stack.GlobalField("nested_global_field_test").Delete(); + Assert.IsNotNull(response); + } + + + } +} \ No newline at end of file diff --git a/Contentstack.Management.Core.Tests/Mock/nested_gf.json b/Contentstack.Management.Core.Tests/Mock/nested_gf.json new file mode 100644 index 0000000..e5382de --- /dev/null +++ b/Contentstack.Management.Core.Tests/Mock/nested_gf.json @@ -0,0 +1,48 @@ +{ + "title": "nested_global_field_test", + "uid": "nested_gf_test", + "description": "Test nested global field for .NET SDK", + "schema": [ + { + "data_type": "text", + "display_name": "Single Line Textbox", + "uid": "single_line", + "field_metadata": { + "description": "", + "default_value": "", + "version": 3 + }, + "format": "", + "error_messages": { + "format": "" + }, + "mandatory": false, + "multiple": false, + "non_localizable": false, + "unique": false + }, + { + "data_type": "global_field", + "display_name": "Global Field Reference", + "reference_to": "referenced_global_field", + "field_metadata": { + "description": "Reference to another global field" + }, + "uid": "global_field_reference", + "mandatory": false, + "multiple": false, + "non_localizable": false, + "unique": false + } + ], + "global_field_refs": [ + { + "uid": "referenced_global_field", + "occurrence_count": 1, + "isChild": true, + "paths": [ + "schema.1" + ] + } + ] +} \ No newline at end of file diff --git a/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationModelsTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationModelsTest.cs index b5984b7..0e5a8b5 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationModelsTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationModelsTest.cs @@ -12,7 +12,7 @@ public class BulkOperationModelsTest [TestMethod] public void BulkPublishDetails_Serialization_Test() { - // Arrange + var details = new BulkPublishDetails { Entries = new List @@ -41,11 +41,10 @@ public void BulkPublishDetails_Serialization_Test() Environments = new List { "env_1", "env_2" } }; - // Act + var json = JsonConvert.SerializeObject(details); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Entries.Count); Assert.AreEqual(2, deserialized.Assets.Count); @@ -65,7 +64,7 @@ public void BulkPublishDetails_Serialization_Test() [TestMethod] public void BulkPublishEntry_WithContentType_Serialization_Test() { - // Arrange + var entry = new BulkPublishEntry { Uid = "entry_uid", @@ -74,11 +73,10 @@ public void BulkPublishEntry_WithContentType_Serialization_Test() Locale = "en-us" }; - // Act + var json = JsonConvert.SerializeObject(entry); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual("entry_uid", deserialized.Uid); Assert.AreEqual("content_type_1", deserialized.ContentType); @@ -89,7 +87,7 @@ public void BulkPublishEntry_WithContentType_Serialization_Test() [TestMethod] public void BulkDeleteDetails_Serialization_Test() { - // Arrange + var details = new BulkDeleteDetails { Entries = new List @@ -114,11 +112,10 @@ public void BulkDeleteDetails_Serialization_Test() } }; - // Act + var json = JsonConvert.SerializeObject(details); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Entries.Count); Assert.AreEqual(2, deserialized.Assets.Count); @@ -132,7 +129,7 @@ public void BulkDeleteDetails_Serialization_Test() [TestMethod] public void BulkWorkflowUpdateBody_Serialization_Test() { - // Arrange + var updateBody = new BulkWorkflowUpdateBody { Entries = new List @@ -170,11 +167,10 @@ public void BulkWorkflowUpdateBody_Serialization_Test() } }; - // Act + var json = JsonConvert.SerializeObject(updateBody); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(1, deserialized.Entries.Count); Assert.IsNotNull(deserialized.Workflow); @@ -205,7 +201,7 @@ public void BulkWorkflowUpdateBody_Serialization_Test() [TestMethod] public void BulkAddItemsData_Serialization_Test() { - // Arrange + var data = new BulkAddItemsData { Items = new List @@ -223,11 +219,10 @@ public void BulkAddItemsData_Serialization_Test() } }; - // Act + var json = JsonConvert.SerializeObject(data); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Items.Count); @@ -239,18 +234,17 @@ public void BulkAddItemsData_Serialization_Test() [TestMethod] public void BulkPublishDetails_EmptyCollections_Test() { - // Arrange + var details = new BulkPublishDetails { Entries = new List(), Assets = new List() }; - // Act + var json = JsonConvert.SerializeObject(details); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); // Collections may be null after deserialization due to ShouldSerialize methods // Initialize them if they're null @@ -267,7 +261,7 @@ public void BulkPublishDetails_EmptyCollections_Test() [TestMethod] public void BulkPublishDetails_WithRulesAndScheduling_Test() { - // Arrange + var details = new BulkPublishDetails { Entries = new List @@ -290,11 +284,10 @@ public void BulkPublishDetails_WithRulesAndScheduling_Test() PublishWithReference = true }; - // Act + var json = JsonConvert.SerializeObject(details); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(1, deserialized.Entries.Count); Assert.AreEqual(1, deserialized.Locales.Count); @@ -314,7 +307,7 @@ public void BulkPublishDetails_WithRulesAndScheduling_Test() [TestMethod] public void BulkWorkflowStage_EmptyCollections_Test() { - // Arrange + var workflowStage = new BulkWorkflowStage { Uid = "test_uid", @@ -323,11 +316,10 @@ public void BulkWorkflowStage_EmptyCollections_Test() AssignedByRoles = new List() }; - // Act + var json = JsonConvert.SerializeObject(workflowStage); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual("test_uid", deserialized.Uid); Assert.AreEqual("test_comment", deserialized.Comment); @@ -342,18 +334,17 @@ public void BulkWorkflowStage_EmptyCollections_Test() [TestMethod] public void BulkPublishEntry_NullValues_Test() { - // Arrange + var entry = new BulkPublishEntry { Uid = "entry_uid" // Version is null by default }; - // Act + var json = JsonConvert.SerializeObject(entry); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual("entry_uid", deserialized.Uid); Assert.AreEqual(0, deserialized.Version); // int defaults to 0, not null diff --git a/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationsUnitTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationsUnitTest.cs index 805d3cd..da37367 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationsUnitTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/BulkOperation/BulkOperationsUnitTest.cs @@ -11,7 +11,7 @@ public class BulkOperationsUnitTest [TestMethod] public void Test001_BulkReleaseItemsData_Serialization() { - // Arrange + var releaseData = new BulkReleaseItemsData { Release = "release_uid", @@ -31,10 +31,9 @@ public void Test001_BulkReleaseItemsData_Serialization() } }; - // Act + var json = JsonConvert.SerializeObject(releaseData); - // Assert Assert.IsNotNull(json); Assert.IsTrue(json.Contains("release")); Assert.IsTrue(json.Contains("action")); @@ -50,7 +49,7 @@ public void Test001_BulkReleaseItemsData_Serialization() [TestMethod] public void Test002_BulkReleaseItem_Serialization() { - // Arrange + var item = new BulkReleaseItem { ContentTypeUid = "ct_1", @@ -60,10 +59,9 @@ public void Test002_BulkReleaseItem_Serialization() Title = "validation test" }; - // Act + var json = JsonConvert.SerializeObject(item); - // Assert Assert.IsNotNull(json); Assert.IsTrue(json.Contains("content_type_uid")); Assert.IsTrue(json.Contains("uid")); @@ -75,7 +73,7 @@ public void Test002_BulkReleaseItem_Serialization() [TestMethod] public void Test003_BulkReleaseItemsData_Deserialization() { - // Arrange + var json = @"{ ""release"": ""release_uid"", ""action"": ""publish"", @@ -92,10 +90,9 @@ public void Test003_BulkReleaseItemsData_Deserialization() ] }"; - // Act + var releaseData = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(releaseData); Assert.AreEqual("release_uid", releaseData.Release); Assert.AreEqual("publish", releaseData.Action); @@ -113,7 +110,7 @@ public void Test003_BulkReleaseItemsData_Deserialization() [TestMethod] public void Test004_BulkReleaseItem_Deserialization() { - // Arrange + var json = @"{ ""content_type_uid"": ""ct_1"", ""uid"": ""uid"", @@ -122,10 +119,9 @@ public void Test004_BulkReleaseItem_Deserialization() ""title"": ""validation test"" }"; - // Act + var item = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(item); Assert.AreEqual("ct_1", item.ContentTypeUid); Assert.AreEqual("uid", item.Uid); @@ -137,17 +133,16 @@ public void Test004_BulkReleaseItem_Deserialization() [TestMethod] public void Test005_BulkReleaseItemsData_Empty_Collections() { - // Arrange + var releaseData = new BulkReleaseItemsData { Locale = new List(), Items = new List() }; - // Act + var json = JsonConvert.SerializeObject(releaseData); - // Assert Assert.IsNotNull(json); Assert.IsNotNull(releaseData.Locale); Assert.IsNotNull(releaseData.Items); @@ -158,7 +153,7 @@ public void Test005_BulkReleaseItemsData_Empty_Collections() [TestMethod] public void Test006_BulkReleaseItemsData_Multiple_Items() { - // Arrange + var releaseData = new BulkReleaseItemsData { Release = "release_uid", @@ -186,11 +181,10 @@ public void Test006_BulkReleaseItemsData_Multiple_Items() } }; - // Act + var json = JsonConvert.SerializeObject(releaseData); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Items.Count); Assert.AreEqual(2, deserialized.Locale.Count); @@ -203,7 +197,7 @@ public void Test006_BulkReleaseItemsData_Multiple_Items() [TestMethod] public void Test007_BulkReleaseItemsData_Different_Actions() { - // Arrange + var publishData = new BulkReleaseItemsData { Release = "release_uid", @@ -222,11 +216,10 @@ public void Test007_BulkReleaseItemsData_Different_Actions() Items = new List() }; - // Act + var publishJson = JsonConvert.SerializeObject(publishData); var unpublishJson = JsonConvert.SerializeObject(unpublishData); - // Assert Assert.IsTrue(publishJson.Contains("publish")); Assert.IsTrue(publishJson.Contains("true")); Assert.IsTrue(unpublishJson.Contains("unpublish")); @@ -236,7 +229,7 @@ public void Test007_BulkReleaseItemsData_Different_Actions() [TestMethod] public void Test008_BulkPublishDetails_Serialization() { - // Arrange + var publishDetails = new BulkPublishDetails { Entries = new List @@ -259,10 +252,9 @@ public void Test008_BulkPublishDetails_Serialization() PublishWithReference = true }; - // Act + var json = JsonConvert.SerializeObject(publishDetails); - // Assert Assert.IsNotNull(json); Assert.IsTrue(json.Contains("entries")); Assert.IsTrue(json.Contains("locales")); @@ -276,7 +268,7 @@ public void Test008_BulkPublishDetails_Serialization() [TestMethod] public void Test009_BulkPublishDetails_Deserialization() { - // Arrange + var json = @"{ ""entries"": [ { @@ -295,10 +287,9 @@ public void Test009_BulkPublishDetails_Deserialization() ""publish_with_reference"": true }"; - // Act + var publishDetails = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(publishDetails); Assert.AreEqual(1, publishDetails.Entries.Count); Assert.AreEqual(1, publishDetails.Locales.Count); @@ -318,7 +309,7 @@ public void Test009_BulkPublishDetails_Deserialization() [TestMethod] public void Test010_BulkPublishEntry_Serialization() { - // Arrange + var entry = new BulkPublishEntry { Uid = "entry_uid", @@ -327,10 +318,9 @@ public void Test010_BulkPublishEntry_Serialization() Locale = "en-us" }; - // Act + var json = JsonConvert.SerializeObject(entry); - // Assert Assert.IsNotNull(json); Assert.IsTrue(json.Contains("uid")); Assert.IsTrue(json.Contains("content_type")); @@ -341,16 +331,15 @@ public void Test010_BulkPublishEntry_Serialization() [TestMethod] public void Test011_BulkPublishRules_Serialization() { - // Arrange + var rules = new BulkPublishRules { Approvals = "true" }; - // Act + var json = JsonConvert.SerializeObject(rules); - // Assert Assert.IsNotNull(json); Assert.IsTrue(json.Contains("approvals")); Assert.IsTrue(json.Contains("true")); @@ -359,15 +348,14 @@ public void Test011_BulkPublishRules_Serialization() [TestMethod] public void Test012_BulkPublishRules_Deserialization() { - // Arrange + var json = @"{ ""approvals"": ""false"" }"; - // Act + var rules = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(rules); Assert.AreEqual("false", rules.Approvals); } @@ -375,7 +363,7 @@ public void Test012_BulkPublishRules_Deserialization() [TestMethod] public void Test013_BulkPublishDetails_Multiple_Entries() { - // Arrange + var publishDetails = new BulkPublishDetails { Entries = new List @@ -407,11 +395,10 @@ public void Test013_BulkPublishDetails_Multiple_Entries() PublishWithReference = true }; - // Act + var json = JsonConvert.SerializeObject(publishDetails); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(3, deserialized.Entries.Count); Assert.AreEqual("entry_uid", deserialized.Entries[0].Uid); @@ -425,7 +412,7 @@ public void Test013_BulkPublishDetails_Multiple_Entries() [TestMethod] public void Test014_BulkPublishDetails_With_Assets() { - // Arrange + var publishDetails = new BulkPublishDetails { Entries = new List @@ -446,11 +433,10 @@ public void Test014_BulkPublishDetails_With_Assets() Environments = new List { "env1" } }; - // Act + var json = JsonConvert.SerializeObject(publishDetails); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(1, deserialized.Entries.Count); Assert.AreEqual(1, deserialized.Assets.Count); @@ -460,16 +446,15 @@ public void Test014_BulkPublishDetails_With_Assets() [TestMethod] public void Test015_BulkPublishAsset_Serialization() { - // Arrange + var asset = new BulkPublishAsset { Uid = "asset_uid" }; - // Act + var json = JsonConvert.SerializeObject(asset); - // Assert Assert.IsNotNull(json); Assert.IsTrue(json.Contains("uid")); Assert.IsTrue(json.Contains("asset_uid")); @@ -478,18 +463,17 @@ public void Test015_BulkPublishAsset_Serialization() [TestMethod] public void Test016_BulkPublishDetails_Empty_Collections() { - // Arrange + var publishDetails = new BulkPublishDetails { Entries = new List(), Assets = new List() }; - // Act + var json = JsonConvert.SerializeObject(publishDetails); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); // Collections may be null after deserialization due to ShouldSerialize methods // Initialize them if they're null @@ -506,7 +490,7 @@ public void Test016_BulkPublishDetails_Empty_Collections() [TestMethod] public void Test017_BulkReleaseItemsData_Null_Values() { - // Arrange + var releaseData = new BulkReleaseItemsData { Release = null, @@ -523,10 +507,9 @@ public void Test017_BulkReleaseItemsData_Null_Values() } }; - // Act + var json = JsonConvert.SerializeObject(releaseData); - // Assert Assert.IsNotNull(json); // Should handle null values gracefully } @@ -534,7 +517,7 @@ public void Test017_BulkReleaseItemsData_Null_Values() [TestMethod] public void Test018_BulkPublishDetails_Null_Values() { - // Arrange + var publishDetails = new BulkPublishDetails { Rules = null, @@ -550,10 +533,9 @@ public void Test018_BulkPublishDetails_Null_Values() } }; - // Act + var json = JsonConvert.SerializeObject(publishDetails); - // Assert Assert.IsNotNull(json); // Should handle null values gracefully } @@ -561,7 +543,6 @@ public void Test018_BulkPublishDetails_Null_Values() [TestMethod] public void Test019_BulkReleaseItemsData_Complex_Scenario() { - // Arrange - Complex scenario with multiple items and different locales var releaseData = new BulkReleaseItemsData { Release = "release_uid", @@ -597,11 +578,10 @@ public void Test019_BulkReleaseItemsData_Complex_Scenario() } }; - // Act + var json = JsonConvert.SerializeObject(releaseData); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(3, deserialized.Locale.Count); Assert.AreEqual(3, deserialized.Items.Count); @@ -616,7 +596,6 @@ public void Test019_BulkReleaseItemsData_Complex_Scenario() [TestMethod] public void Test020_BulkPublishDetails_Complex_Scenario() { - // Arrange - Complex scenario with multiple entries, assets, and rules var publishDetails = new BulkPublishDetails { Entries = new List @@ -651,11 +630,10 @@ public void Test020_BulkPublishDetails_Complex_Scenario() PublishWithReference = true }; - // Act + var json = JsonConvert.SerializeObject(publishDetails); var deserialized = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(deserialized); Assert.AreEqual(2, deserialized.Entries.Count); Assert.AreEqual(2, deserialized.Assets.Count); diff --git a/Contentstack.Management.Core.Unit.Tests/Models/BulkReleaseItemsTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/BulkReleaseItemsTest.cs index e081509..f1987f8 100644 --- a/Contentstack.Management.Core.Unit.Tests/Models/BulkReleaseItemsTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Models/BulkReleaseItemsTest.cs @@ -11,7 +11,7 @@ public class BulkReleaseItemsTest [TestMethod] public void Test001_BulkReleaseItemsData_Serialization() { - // Arrange + var releaseData = new BulkReleaseItemsData { Release = "release_uid", @@ -31,10 +31,9 @@ public void Test001_BulkReleaseItemsData_Serialization() } }; - // Act + var json = JsonConvert.SerializeObject(releaseData); - // Assert Assert.IsNotNull(json); Assert.IsTrue(json.Contains("release")); Assert.IsTrue(json.Contains("action")); @@ -50,7 +49,7 @@ public void Test001_BulkReleaseItemsData_Serialization() [TestMethod] public void Test002_BulkReleaseItem_Serialization() { - // Arrange + var item = new BulkReleaseItem { ContentTypeUid = "ct_1", @@ -60,10 +59,9 @@ public void Test002_BulkReleaseItem_Serialization() Title = "validation test" }; - // Act + var json = JsonConvert.SerializeObject(item); - // Assert Assert.IsNotNull(json); Assert.IsTrue(json.Contains("content_type_uid")); Assert.IsTrue(json.Contains("uid")); @@ -75,7 +73,7 @@ public void Test002_BulkReleaseItem_Serialization() [TestMethod] public void Test003_BulkReleaseItemsData_Deserialization() { - // Arrange + var json = @"{ ""release"": ""release_uid"", ""action"": ""publish"", @@ -92,10 +90,9 @@ public void Test003_BulkReleaseItemsData_Deserialization() ] }"; - // Act + var releaseData = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(releaseData); Assert.AreEqual("release_uid", releaseData.Release); Assert.AreEqual("publish", releaseData.Action); @@ -113,7 +110,7 @@ public void Test003_BulkReleaseItemsData_Deserialization() [TestMethod] public void Test004_BulkReleaseItem_Deserialization() { - // Arrange + var json = @"{ ""content_type_uid"": ""ct_1"", ""uid"": ""uid"", @@ -122,10 +119,9 @@ public void Test004_BulkReleaseItem_Deserialization() ""title"": ""validation test"" }"; - // Act + var item = JsonConvert.DeserializeObject(json); - // Assert Assert.IsNotNull(item); Assert.AreEqual("ct_1", item.ContentTypeUid); Assert.AreEqual("uid", item.Uid); @@ -137,17 +133,16 @@ public void Test004_BulkReleaseItem_Deserialization() [TestMethod] public void Test005_BulkReleaseItemsData_Empty_Collections() { - // Arrange + var releaseData = new BulkReleaseItemsData { Locale = new List(), Items = new List() }; - // Act + var json = JsonConvert.SerializeObject(releaseData); - // Assert Assert.IsNotNull(json); Assert.IsNotNull(releaseData.Locale); Assert.IsNotNull(releaseData.Items); diff --git a/Contentstack.Management.Core.Unit.Tests/Models/ContentModellingNestedGlobalFieldTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/ContentModellingNestedGlobalFieldTest.cs new file mode 100644 index 0000000..edd35b9 --- /dev/null +++ b/Contentstack.Management.Core.Unit.Tests/Models/ContentModellingNestedGlobalFieldTest.cs @@ -0,0 +1,363 @@ +using System; +using System.Collections.Generic; +using AutoFixture; +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 +{ + [TestClass] + public class ContentModellingNestedGlobalFieldTest + { + private readonly IFixture _fixture = new Fixture(); + + [TestMethod] + public void Should_Create_ContentModelling_With_Nested_Global_Fields() + { + var contentModelling = new ContentModelling + { + Title = "nested_global_field_test", + Uid = "nested_global_field_test", + Description = "Test nested global field functionality", + Schema = new List + { + new TextboxField + { + DisplayName = "Title", + Uid = "title", + DataType = "text", + Mandatory = true + }, + new GlobalFieldReference + { + DisplayName = "Product Information", + Uid = "product_info", + DataType = "global_field", + ReferenceTo = "referenced_global_field", + Mandatory = true, + Multiple = false, + Unique = false, + NonLocalizable = false + } + }, + GlobalFieldRefs = new List + { + new GlobalFieldRefs + { + Uid = "referenced_global_field", + OccurrenceCount = 1, + IsChild = true, + Paths = new List { "schema.1" } + } + } + }; + + Assert.IsNotNull(contentModelling); + Assert.AreEqual("nested_global_field_test", contentModelling.Title); + Assert.AreEqual("nested_global_field_test", contentModelling.Uid); + Assert.AreEqual("Test nested global field functionality", contentModelling.Description); + Assert.IsNotNull(contentModelling.Schema); + Assert.AreEqual(2, contentModelling.Schema.Count); + Assert.IsNotNull(contentModelling.GlobalFieldRefs); + Assert.AreEqual(1, contentModelling.GlobalFieldRefs.Count); + + var globalFieldRef = contentModelling.Schema[1] as GlobalFieldReference; + Assert.IsNotNull(globalFieldRef); + Assert.AreEqual("Product Information", globalFieldRef.DisplayName); + Assert.AreEqual("product_info", globalFieldRef.Uid); + Assert.AreEqual("global_field", globalFieldRef.DataType); + Assert.AreEqual("referenced_global_field", globalFieldRef.ReferenceTo); + + var globalFieldRefs = contentModelling.GlobalFieldRefs[0]; + Assert.AreEqual("referenced_global_field", globalFieldRefs.Uid); + Assert.AreEqual(1, globalFieldRefs.OccurrenceCount); + Assert.IsTrue(globalFieldRefs.IsChild); + Assert.AreEqual(1, globalFieldRefs.Paths.Count); + Assert.AreEqual("schema.1", globalFieldRefs.Paths[0]); + } + + [TestMethod] + public void Should_Serialize_ContentModelling_With_Nested_Global_Fields() + { + var contentModelling = new ContentModelling + { + Title = "nested_global_field_test", + Uid = "nested_global_field_test", + Description = "Test nested global field functionality", + Schema = new List + { + new TextboxField + { + DisplayName = "Title", + Uid = "title", + DataType = "text", + Mandatory = true + }, + new GlobalFieldReference + { + DisplayName = "Product Information", + Uid = "product_info", + DataType = "global_field", + ReferenceTo = "referenced_global_field", + Mandatory = true, + Multiple = false, + Unique = false, + NonLocalizable = false + } + }, + GlobalFieldRefs = new List + { + new GlobalFieldRefs + { + Uid = "referenced_global_field", + OccurrenceCount = 1, + IsChild = true, + Paths = new List { "schema.1" } + } + } + }; + + var json = JsonConvert.SerializeObject(contentModelling); + + Assert.IsTrue(json.Contains("\"title\":\"nested_global_field_test\"")); + Assert.IsTrue(json.Contains("\"uid\":\"nested_global_field_test\"")); + Assert.IsTrue(json.Contains("\"description\":\"Test nested global field functionality\"")); + Assert.IsTrue(json.Contains("\"schema\"")); + Assert.IsTrue(json.Contains("\"global_field_refs\"")); + Assert.IsTrue(json.Contains("\"data_type\":\"global_field\"")); + Assert.IsTrue(json.Contains("\"reference_to\":\"referenced_global_field\"")); + } + + + + [TestMethod] + public void Should_Create_ContentModelling_With_Multiple_Nested_Global_Fields() + { + var contentModelling = new ContentModelling + { + Title = "Complex Nested Global Field", + Uid = "complex_nested_global_field", + Description = "Complex nested global field with multiple references", + Schema = new List + { + new TextboxField + { + DisplayName = "Title", + Uid = "title", + DataType = "text", + Mandatory = true + }, + new GlobalFieldReference + { + DisplayName = "Product Info", + Uid = "product_info", + DataType = "global_field", + ReferenceTo = "product_information", + Mandatory = true, + Multiple = false + }, + new GlobalFieldReference + { + DisplayName = "Category Info", + Uid = "category_info", + DataType = "global_field", + ReferenceTo = "category_information", + Mandatory = false, + Multiple = true + }, + new GroupField + { + DisplayName = "Additional Info", + Uid = "additional_info", + DataType = "group", + Schema = new List + { + new GlobalFieldReference + { + DisplayName = "Nested Product", + Uid = "nested_product", + DataType = "global_field", + ReferenceTo = "product_information", + Mandatory = true, + Multiple = false + } + } + } + }, + GlobalFieldRefs = new List + { + new GlobalFieldRefs + { + Uid = "product_information", + OccurrenceCount = 2, + IsChild = true, + Paths = new List { "schema.1", "schema.3.schema.0" } + }, + new GlobalFieldRefs + { + Uid = "category_information", + OccurrenceCount = 1, + IsChild = true, + Paths = new List { "schema.2" } + } + } + }; + + Assert.IsNotNull(contentModelling); + Assert.AreEqual("Complex Nested Global Field", contentModelling.Title); + Assert.AreEqual(4, contentModelling.Schema.Count); + Assert.AreEqual(2, contentModelling.GlobalFieldRefs.Count); + + var productInfoRef = contentModelling.Schema[1] as GlobalFieldReference; + Assert.IsNotNull(productInfoRef); + Assert.AreEqual("product_information", productInfoRef.ReferenceTo); + + var categoryInfoRef = contentModelling.Schema[2] as GlobalFieldReference; + Assert.IsNotNull(categoryInfoRef); + Assert.AreEqual("category_information", categoryInfoRef.ReferenceTo); + + var groupField = contentModelling.Schema[3] as GroupField; + Assert.IsNotNull(groupField); + Assert.AreEqual(1, groupField.Schema.Count); + + var nestedProductRef = groupField.Schema[0] as GlobalFieldReference; + Assert.IsNotNull(nestedProductRef); + Assert.AreEqual("product_information", nestedProductRef.ReferenceTo); + + var productRefs = contentModelling.GlobalFieldRefs[0]; + Assert.AreEqual("product_information", productRefs.Uid); + Assert.AreEqual(2, productRefs.OccurrenceCount); + Assert.AreEqual(2, productRefs.Paths.Count); + Assert.AreEqual("schema.1", productRefs.Paths[0]); + Assert.AreEqual("schema.3.schema.0", productRefs.Paths[1]); + + var categoryRefs = contentModelling.GlobalFieldRefs[1]; + Assert.AreEqual("category_information", categoryRefs.Uid); + Assert.AreEqual(1, categoryRefs.OccurrenceCount); + Assert.AreEqual(1, categoryRefs.Paths.Count); + Assert.AreEqual("schema.2", categoryRefs.Paths[0]); + } + + [TestMethod] + public void Should_Handle_ContentModelling_With_Null_GlobalFieldRefs() + { + var contentModelling = new ContentModelling + { + Title = "Simple Global Field", + Uid = "simple_global_field", + Description = "Simple global field without nested references", + Schema = new List + { + new TextboxField + { + DisplayName = "Title", + Uid = "title", + DataType = "text", + Mandatory = true + } + }, + GlobalFieldRefs = null + }; + + var json = JsonConvert.SerializeObject(contentModelling); + Assert.IsTrue(json.Contains("\"title\":\"Simple Global Field\"")); + Assert.IsFalse(json.Contains("\"global_field_refs\"")); + } + + [TestMethod] + public void Should_Handle_ContentModelling_With_Empty_GlobalFieldRefs() + { + var contentModelling = new ContentModelling + { + Title = "Empty Global Field", + Uid = "empty_global_field", + Description = "Global field with empty references", + Schema = new List + { + new TextboxField + { + DisplayName = "Title", + Uid = "title", + DataType = "text", + Mandatory = true + } + }, + GlobalFieldRefs = new List() + }; + + var json = JsonConvert.SerializeObject(contentModelling); + + Assert.IsTrue(json.Contains("\"title\":\"Empty Global Field\"")); + Assert.IsTrue(json.Contains("\"global_field_refs\":[]")); + } + + [TestMethod] + public void Should_Serialize_Complex_ContentModelling_With_Nested_Global_Fields() + { + var contentModelling = new ContentModelling + { + Title = "Complex Nested Global Field", + Uid = "complex_nested_global_field", + Description = "Complex nested global field with multiple references", + Schema = new List + { + new TextboxField + { + DisplayName = "Title", + Uid = "title", + DataType = "text", + Mandatory = true + }, + new GlobalFieldReference + { + DisplayName = "Product Info", + Uid = "product_info", + DataType = "global_field", + ReferenceTo = "product_information", + Mandatory = true, + Multiple = false + }, + new GlobalFieldReference + { + DisplayName = "Category Info", + Uid = "category_info", + DataType = "global_field", + ReferenceTo = "category_information", + Mandatory = false, + Multiple = true + } + }, + GlobalFieldRefs = new List + { + new GlobalFieldRefs + { + Uid = "product_information", + OccurrenceCount = 1, + IsChild = true, + Paths = new List { "schema.1" } + }, + new GlobalFieldRefs + { + Uid = "category_information", + OccurrenceCount = 1, + IsChild = true, + Paths = new List { "schema.2" } + } + } + }; + + var json = JsonConvert.SerializeObject(contentModelling); + + Assert.IsTrue(json.Contains("\"title\":\"Complex Nested Global Field\"")); + Assert.IsTrue(json.Contains("\"global_field_refs\"")); + Assert.IsTrue(json.Contains("\"product_information\"")); + Assert.IsTrue(json.Contains("\"category_information\"")); + Assert.IsTrue(json.Contains("\"occurrence_count\":1")); + Assert.IsTrue(json.Contains("\"isChild\":true")); + } + + + } +} \ No newline at end of file diff --git a/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceSerializationTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceSerializationTest.cs new file mode 100644 index 0000000..36009a6 --- /dev/null +++ b/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceSerializationTest.cs @@ -0,0 +1,277 @@ +using System; +using AutoFixture; +using Contentstack.Management.Core.Models.Fields; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Newtonsoft.Json; + +namespace Contentstack.Management.Core.Unit.Tests.Models.Fields +{ + [TestClass] + public class GlobalFieldReferenceSerializationTest + { + private readonly IFixture _fixture = new Fixture(); + + [TestMethod] + public void Should_Serialize_GlobalFieldReference_To_JSON() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Product Information", + Uid = "product_info", + DataType = "global_field", + ReferenceTo = "referenced_global_field_uid", + Mandatory = true, + Multiple = false, + Unique = false, + NonLocalizable = false, + FieldMetadata = new FieldMetadata + { + Description = "Reference to product information global field" + } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"display_name\":\"Product Information\"")); + Assert.IsTrue(json.Contains("\"uid\":\"product_info\"")); + Assert.IsTrue(json.Contains("\"data_type\":\"global_field\"")); + Assert.IsTrue(json.Contains("\"reference_to\":\"referenced_global_field_uid\"")); + Assert.IsTrue(json.Contains("\"mandatory\":true")); + Assert.IsTrue(json.Contains("\"multiple\":false")); + Assert.IsTrue(json.Contains("\"unique\":false")); + Assert.IsTrue(json.Contains("\"non_localizable\":false")); + } + + [TestMethod] + public void Should_Deserialize_JSON_To_GlobalFieldReference() + { + + var json = @"{ + ""display_name"": ""Product Information"", + ""uid"": ""product_info"", + ""data_type"": ""global_field"", + ""reference_to"": ""referenced_global_field_uid"", + ""mandatory"": true, + ""multiple"": false, + ""unique"": false, + ""non_localizable"": false, + ""field_metadata"": { + ""description"": ""Reference to product information global field"" + } + }"; + + + var globalFieldRef = JsonConvert.DeserializeObject(json); + + Assert.IsNotNull(globalFieldRef); + Assert.AreEqual("Product Information", globalFieldRef.DisplayName); + Assert.AreEqual("product_info", globalFieldRef.Uid); + Assert.AreEqual("global_field", globalFieldRef.DataType); + Assert.AreEqual("referenced_global_field_uid", globalFieldRef.ReferenceTo); + Assert.IsTrue(globalFieldRef.Mandatory); + Assert.IsFalse(globalFieldRef.Multiple); + Assert.IsFalse(globalFieldRef.Unique); + Assert.IsFalse(globalFieldRef.NonLocalizable); + Assert.IsNotNull(globalFieldRef.FieldMetadata); + Assert.AreEqual("Reference to product information global field", globalFieldRef.FieldMetadata.Description); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldReference_With_Multiple_True() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Multiple Products", + Uid = "multiple_products", + DataType = "global_field", + ReferenceTo = "product_info", + Mandatory = false, + Multiple = true, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"multiple\":true")); + Assert.IsTrue(json.Contains("\"mandatory\":false")); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldReference_With_Unique_True() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Unique Product", + Uid = "unique_product", + DataType = "global_field", + ReferenceTo = "product_info", + Mandatory = true, + Multiple = false, + Unique = true, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"unique\":true")); + Assert.IsTrue(json.Contains("\"mandatory\":true")); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldReference_With_NonLocalizable_True() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Non Localizable Product", + Uid = "non_localizable_product", + DataType = "global_field", + ReferenceTo = "product_info", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = true + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"non_localizable\":true")); + } + + [TestMethod] + public void Should_Handle_Null_ReferenceTo() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Field", + Uid = "test_field", + DataType = "global_field", + ReferenceTo = null, + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + // Null values are ignored due to ItemNullValueHandling = NullValueHandling.Ignore + Assert.IsFalse(json.Contains("\"reference_to\"")); + } + + [TestMethod] + public void Should_Handle_Empty_ReferenceTo() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Field", + Uid = "test_field", + DataType = "global_field", + ReferenceTo = "", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + // Empty strings are still serialized + Assert.IsTrue(json.Contains("\"reference_to\":\"\"")); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldReference_With_Complex_FieldMetadata() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Complex Product Reference", + Uid = "complex_product_ref", + DataType = "global_field", + ReferenceTo = "complex_product", + Mandatory = true, + Multiple = true, + Unique = true, + NonLocalizable = false, + FieldMetadata = new FieldMetadata + { + Description = "Complex product reference with rich metadata", + DefaultValue = "default_product", + Version = 3, + AllowRichText = true, + Multiline = false, + RichTextType = "advanced" + } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"field_metadata\"")); + Assert.IsTrue(json.Contains("\"description\":\"Complex product reference with rich metadata\"")); + Assert.IsTrue(json.Contains("\"default_value\":\"default_product\"")); + Assert.IsTrue(json.Contains("\"version\":3")); + Assert.IsTrue(json.Contains("\"allow_rich_text\":true")); + Assert.IsTrue(json.Contains("\"multiline\":false")); + Assert.IsTrue(json.Contains("\"rich_text_type\":\"advanced\"")); + } + + [TestMethod] + public void Should_Deserialize_Complex_JSON_To_GlobalFieldReference() + { + + var json = @"{ + ""display_name"": ""Complex Product Reference"", + ""uid"": ""complex_product_ref"", + ""data_type"": ""global_field"", + ""reference_to"": ""complex_product"", + ""mandatory"": true, + ""multiple"": true, + ""unique"": true, + ""non_localizable"": false, + ""field_metadata"": { + ""description"": ""Complex product reference with rich metadata"", + ""default_value"": ""default_product"", + ""version"": 3, + ""allow_rich_text"": true, + ""multiline"": false, + ""rich_text_type"": ""advanced"" + } + }"; + + + var globalFieldRef = JsonConvert.DeserializeObject(json); + + Assert.IsNotNull(globalFieldRef); + Assert.AreEqual("Complex Product Reference", globalFieldRef.DisplayName); + Assert.AreEqual("complex_product_ref", globalFieldRef.Uid); + Assert.AreEqual("global_field", globalFieldRef.DataType); + Assert.AreEqual("complex_product", globalFieldRef.ReferenceTo); + Assert.IsTrue(globalFieldRef.Mandatory); + Assert.IsTrue(globalFieldRef.Multiple); + Assert.IsTrue(globalFieldRef.Unique); + Assert.IsFalse(globalFieldRef.NonLocalizable); + + Assert.IsNotNull(globalFieldRef.FieldMetadata); + Assert.AreEqual("Complex product reference with rich metadata", globalFieldRef.FieldMetadata.Description); + Assert.AreEqual("default_product", globalFieldRef.FieldMetadata.DefaultValue); + Assert.AreEqual(3, globalFieldRef.FieldMetadata.Version); + Assert.IsTrue(globalFieldRef.FieldMetadata.AllowRichText); + Assert.IsFalse(globalFieldRef.FieldMetadata.Multiline); + Assert.AreEqual("advanced", globalFieldRef.FieldMetadata.RichTextType); + } + } +} \ No newline at end of file diff --git a/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceTest.cs new file mode 100644 index 0000000..81ce8b5 --- /dev/null +++ b/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceTest.cs @@ -0,0 +1,125 @@ +using System; +using AutoFixture; +using Contentstack.Management.Core.Models.Fields; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Newtonsoft.Json; + +namespace Contentstack.Management.Core.Unit.Tests.Models.Fields +{ + [TestClass] + public class GlobalFieldReferenceTest + { + private readonly IFixture _fixture = new Fixture(); + + [TestMethod] + public void Should_Create_GlobalFieldReference_With_All_Properties() + { + + var displayName = _fixture.Create(); + var uid = _fixture.Create(); + var referenceTo = _fixture.Create(); + var fieldMetadata = new FieldMetadata + { + Description = "Test description" + }; + + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = displayName, + Uid = uid, + DataType = "global_field", + ReferenceTo = referenceTo, + FieldMetadata = fieldMetadata, + Multiple = true, + Mandatory = false, + Unique = false, + NonLocalizable = true + }; + + Assert.AreEqual(displayName, globalFieldRef.DisplayName); + Assert.AreEqual(uid, globalFieldRef.Uid); + Assert.AreEqual("global_field", globalFieldRef.DataType); + Assert.AreEqual(referenceTo, globalFieldRef.ReferenceTo); + Assert.AreEqual(fieldMetadata, globalFieldRef.FieldMetadata); + Assert.IsTrue(globalFieldRef.Multiple); + Assert.IsFalse(globalFieldRef.Mandatory); + Assert.IsFalse(globalFieldRef.Unique); + Assert.IsTrue(globalFieldRef.NonLocalizable); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldReference_Correctly() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Global Field Reference", + Uid = "test_global_field_ref", + DataType = "global_field", + ReferenceTo = "referenced_global_field", + FieldMetadata = new FieldMetadata + { + Description = "Test description" + }, + Multiple = false, + Mandatory = true, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"display_name\":\"Test Global Field Reference\"")); + Assert.IsTrue(json.Contains("\"uid\":\"test_global_field_ref\"")); + Assert.IsTrue(json.Contains("\"data_type\":\"global_field\"")); + Assert.IsTrue(json.Contains("\"reference_to\":\"referenced_global_field\"")); + Assert.IsTrue(json.Contains("\"mandatory\":true")); + Assert.IsTrue(json.Contains("\"multiple\":false")); + Assert.IsTrue(json.Contains("\"unique\":false")); + Assert.IsTrue(json.Contains("\"non_localizable\":false")); + } + + [TestMethod] + public void Should_Deserialize_GlobalFieldReference_Correctly() + { + + var json = @"{ + ""display_name"": ""Test Global Field Reference"", + ""uid"": ""test_global_field_ref"", + ""data_type"": ""global_field"", + ""reference_to"": ""referenced_global_field"", + ""field_metadata"": { + ""description"": ""Test description"" + }, + ""mandatory"": true, + ""multiple"": false, + ""unique"": false, + ""non_localizable"": false + }"; + + + var globalFieldRef = JsonConvert.DeserializeObject(json); + + Assert.AreEqual("Test Global Field Reference", globalFieldRef.DisplayName); + Assert.AreEqual("test_global_field_ref", globalFieldRef.Uid); + Assert.AreEqual("global_field", globalFieldRef.DataType); + Assert.AreEqual("referenced_global_field", globalFieldRef.ReferenceTo); + Assert.IsNotNull(globalFieldRef.FieldMetadata); + Assert.AreEqual("Test description", globalFieldRef.FieldMetadata.Description); + Assert.IsTrue(globalFieldRef.Mandatory); + Assert.IsFalse(globalFieldRef.Multiple); + Assert.IsFalse(globalFieldRef.Unique); + Assert.IsFalse(globalFieldRef.NonLocalizable); + } + + [TestMethod] + public void Should_Inherit_From_Field_Base_Class() + { + var globalFieldRef = new GlobalFieldReference(); + + Assert.IsInstanceOfType(globalFieldRef, typeof(Field)); + } + } +} \ No newline at end of file diff --git a/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceValidationTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceValidationTest.cs new file mode 100644 index 0000000..4cf660d --- /dev/null +++ b/Contentstack.Management.Core.Unit.Tests/Models/Fields/GlobalFieldReferenceValidationTest.cs @@ -0,0 +1,441 @@ +using System; +using System.Collections.Generic; +using AutoFixture; +using Contentstack.Management.Core.Models.Fields; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Newtonsoft.Json; + +namespace Contentstack.Management.Core.Unit.Tests.Models.Fields +{ + [TestClass] + public class GlobalFieldReferenceValidationTest + { + private readonly IFixture _fixture = new Fixture(); + + [TestMethod] + public void Should_Validate_GlobalFieldReference_With_Valid_Data() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Valid Product Reference", + Uid = "valid_product_ref", + DataType = "global_field", + ReferenceTo = "valid_global_field_uid", + Mandatory = true, + Multiple = false, + Unique = false, + NonLocalizable = false, + FieldMetadata = new FieldMetadata + { + Description = "Valid reference to global field" + } + }; + + + Assert.IsNotNull(globalFieldRef); + Assert.AreEqual("global_field", globalFieldRef.DataType); + Assert.IsFalse(string.IsNullOrEmpty(globalFieldRef.ReferenceTo)); + Assert.IsNotNull(globalFieldRef.FieldMetadata); + } + + [TestMethod] + public void Should_Handle_GlobalFieldReference_With_Empty_DisplayName() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "", + Uid = "test_field", + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"display_name\":\"\"")); + Assert.AreEqual("", globalFieldRef.DisplayName); + } + + [TestMethod] + public void Should_Handle_GlobalFieldReference_With_Null_DisplayName() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = null, + Uid = "test_field", + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + // Null values are ignored due to ItemNullValueHandling = NullValueHandling.Ignore + Assert.IsFalse(json.Contains("\"display_name\"")); + Assert.IsNull(globalFieldRef.DisplayName); + } + + [TestMethod] + public void Should_Handle_GlobalFieldReference_With_Empty_Uid() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Field", + Uid = "", + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"uid\":\"\"")); + Assert.AreEqual("", globalFieldRef.Uid); + } + + [TestMethod] + public void Should_Handle_GlobalFieldReference_With_Null_Uid() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Field", + Uid = null, + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + // Null values are ignored due to ItemNullValueHandling = NullValueHandling.Ignore + Assert.IsFalse(json.Contains("\"uid\"")); + Assert.IsNull(globalFieldRef.Uid); + } + + [TestMethod] + public void Should_Handle_GlobalFieldReference_With_Empty_ReferenceTo() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Field", + Uid = "test_field", + DataType = "global_field", + ReferenceTo = "", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"reference_to\":\"\"")); + Assert.AreEqual("", globalFieldRef.ReferenceTo); + } + + [TestMethod] + public void Should_Handle_GlobalFieldReference_With_Null_ReferenceTo() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Field", + Uid = "test_field", + DataType = "global_field", + ReferenceTo = null, + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + // Null values are ignored due to ItemNullValueHandling = NullValueHandling.Ignore + Assert.IsFalse(json.Contains("\"reference_to\"")); + Assert.IsNull(globalFieldRef.ReferenceTo); + } + + [TestMethod] + public void Should_Handle_GlobalFieldReference_With_Null_FieldMetadata() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Field", + Uid = "test_field", + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false, + FieldMetadata = null + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + // Null values are ignored due to ItemNullValueHandling = NullValueHandling.Ignore + Assert.IsFalse(json.Contains("\"field_metadata\"")); + Assert.IsNull(globalFieldRef.FieldMetadata); + } + + [TestMethod] + public void Should_Handle_GlobalFieldReference_With_Empty_FieldMetadata() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Test Field", + Uid = "test_field", + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false, + FieldMetadata = new FieldMetadata() + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"field_metadata\"")); + Assert.IsNotNull(globalFieldRef.FieldMetadata); + } + + [TestMethod] + public void Should_Validate_GlobalFieldReference_With_Special_Characters_In_Uid() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Special Characters Test", + Uid = "test-field_with_underscores.and.dots", + DataType = "global_field", + ReferenceTo = "referenced-field_with_underscores.and.dots", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"uid\":\"test-field_with_underscores.and.dots\"")); + Assert.IsTrue(json.Contains("\"reference_to\":\"referenced-field_with_underscores.and.dots\"")); + Assert.AreEqual("test-field_with_underscores.and.dots", globalFieldRef.Uid); + Assert.AreEqual("referenced-field_with_underscores.and.dots", globalFieldRef.ReferenceTo); + } + + [TestMethod] + public void Should_Validate_GlobalFieldReference_With_Unicode_Characters() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Unicode Test 中文", + Uid = "test_field_中文", + DataType = "global_field", + ReferenceTo = "referenced_field_中文", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains("\"display_name\":\"Unicode Test 中文\"")); + Assert.IsTrue(json.Contains("\"uid\":\"test_field_中文\"")); + Assert.IsTrue(json.Contains("\"reference_to\":\"referenced_field_中文\"")); + Assert.AreEqual("Unicode Test 中文", globalFieldRef.DisplayName); + Assert.AreEqual("test_field_中文", globalFieldRef.Uid); + Assert.AreEqual("referenced_field_中文", globalFieldRef.ReferenceTo); + } + + [TestMethod] + public void Should_Validate_GlobalFieldReference_With_Long_Strings() + { + + var longString = new string('a', 1000); + var globalFieldRef = new GlobalFieldReference + { + DisplayName = longString, + Uid = longString, + DataType = "global_field", + ReferenceTo = longString, + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false, + FieldMetadata = new FieldMetadata + { + Description = longString + } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsTrue(json.Contains($"\"display_name\":\"{longString}\"")); + Assert.IsTrue(json.Contains($"\"uid\":\"{longString}\"")); + Assert.IsTrue(json.Contains($"\"reference_to\":\"{longString}\"")); + Assert.AreEqual(longString, globalFieldRef.DisplayName); + Assert.AreEqual(longString, globalFieldRef.Uid); + Assert.AreEqual(longString, globalFieldRef.ReferenceTo); + } + + [TestMethod] + public void Should_Validate_GlobalFieldReference_With_All_Boolean_Combinations() + { + // Test all combinations of boolean properties + var combinations = new[] + { + new { Mandatory = false, Multiple = false, Unique = false, NonLocalizable = false }, + new { Mandatory = true, Multiple = false, Unique = false, NonLocalizable = false }, + new { Mandatory = false, Multiple = true, Unique = false, NonLocalizable = false }, + new { Mandatory = false, Multiple = false, Unique = true, NonLocalizable = false }, + new { Mandatory = false, Multiple = false, Unique = false, NonLocalizable = true }, + new { Mandatory = true, Multiple = true, Unique = false, NonLocalizable = false }, + new { Mandatory = true, Multiple = false, Unique = true, NonLocalizable = false }, + new { Mandatory = true, Multiple = false, Unique = false, NonLocalizable = true }, + new { Mandatory = false, Multiple = true, Unique = true, NonLocalizable = false }, + new { Mandatory = false, Multiple = true, Unique = false, NonLocalizable = true }, + new { Mandatory = false, Multiple = false, Unique = true, NonLocalizable = true }, + new { Mandatory = true, Multiple = true, Unique = true, NonLocalizable = false }, + new { Mandatory = true, Multiple = true, Unique = false, NonLocalizable = true }, + new { Mandatory = true, Multiple = false, Unique = true, NonLocalizable = true }, + new { Mandatory = false, Multiple = true, Unique = true, NonLocalizable = true }, + new { Mandatory = true, Multiple = true, Unique = true, NonLocalizable = true } + }; + + foreach (var combo in combinations) + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Boolean Test", + Uid = "boolean_test", + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = combo.Mandatory, + Multiple = combo.Multiple, + Unique = combo.Unique, + NonLocalizable = combo.NonLocalizable + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.AreEqual(combo.Mandatory, globalFieldRef.Mandatory); + Assert.AreEqual(combo.Multiple, globalFieldRef.Multiple); + Assert.AreEqual(combo.Unique, globalFieldRef.Unique); + Assert.AreEqual(combo.NonLocalizable, globalFieldRef.NonLocalizable); + + Assert.IsTrue(json.Contains($"\"mandatory\":{combo.Mandatory.ToString().ToLower()}")); + Assert.IsTrue(json.Contains($"\"multiple\":{combo.Multiple.ToString().ToLower()}")); + Assert.IsTrue(json.Contains($"\"unique\":{combo.Unique.ToString().ToLower()}")); + Assert.IsTrue(json.Contains($"\"non_localizable\":{combo.NonLocalizable.ToString().ToLower()}")); + } + } + + [TestMethod] + public void Should_Validate_GlobalFieldReference_With_Complex_FieldMetadata() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Complex Metadata Test", + Uid = "complex_metadata_test", + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = true, + Multiple = true, + Unique = true, + NonLocalizable = false, + FieldMetadata = new FieldMetadata + { + Description = "Complex metadata description", + DefaultValue = "default_value", + Version = 3, + AllowRichText = true, + Multiline = false, + RichTextType = "advanced", + Options = new List { "option1", "option2", "option3" } + } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.IsNotNull(globalFieldRef.FieldMetadata); + Assert.AreEqual("Complex metadata description", globalFieldRef.FieldMetadata.Description); + Assert.AreEqual("default_value", globalFieldRef.FieldMetadata.DefaultValue); + Assert.AreEqual(3, globalFieldRef.FieldMetadata.Version); + Assert.IsTrue(globalFieldRef.FieldMetadata.AllowRichText); + Assert.IsFalse(globalFieldRef.FieldMetadata.Multiline); + Assert.AreEqual("advanced", globalFieldRef.FieldMetadata.RichTextType); + Assert.IsNotNull(globalFieldRef.FieldMetadata.Options); + Assert.AreEqual(3, globalFieldRef.FieldMetadata.Options.Count); + + Assert.IsTrue(json.Contains("\"field_metadata\"")); + Assert.IsTrue(json.Contains("\"description\":\"Complex metadata description\"")); + Assert.IsTrue(json.Contains("\"default_value\":\"default_value\"")); + Assert.IsTrue(json.Contains("\"version\":3")); + Assert.IsTrue(json.Contains("\"allow_rich_text\":true")); + Assert.IsTrue(json.Contains("\"multiline\":false")); + Assert.IsTrue(json.Contains("\"rich_text_type\":\"advanced\"")); + } + + [TestMethod] + public void Should_Validate_GlobalFieldReference_Data_Type_Is_Always_GlobalField() + { + + var globalFieldRef = new GlobalFieldReference + { + DisplayName = "Data Type Test", + Uid = "data_type_test", + DataType = "global_field", + ReferenceTo = "referenced_field", + Mandatory = false, + Multiple = false, + Unique = false, + NonLocalizable = false + }; + + + var json = JsonConvert.SerializeObject(globalFieldRef); + + Assert.AreEqual("global_field", globalFieldRef.DataType); + Assert.IsTrue(json.Contains("\"data_type\":\"global_field\"")); + } + } +} \ No newline at end of file diff --git a/Contentstack.Management.Core.Unit.Tests/Models/GlobalFieldRefsSerializationTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/GlobalFieldRefsSerializationTest.cs new file mode 100644 index 0000000..5aa8cc4 --- /dev/null +++ b/Contentstack.Management.Core.Unit.Tests/Models/GlobalFieldRefsSerializationTest.cs @@ -0,0 +1,317 @@ +using System; +using System.Collections.Generic; +using AutoFixture; +using Contentstack.Management.Core.Models; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Newtonsoft.Json; + +namespace Contentstack.Management.Core.Unit.Tests.Models +{ + [TestClass] + public class GlobalFieldRefsSerializationTest + { + private readonly IFixture _fixture = new Fixture(); + + [TestMethod] + public void Should_Serialize_GlobalFieldRefs_To_JSON() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "referenced_global_field_uid", + OccurrenceCount = 2, + IsChild = true, + Paths = new List { "schema.1", "schema.3.schema.1" } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"uid\":\"referenced_global_field_uid\"")); + Assert.IsTrue(json.Contains("\"occurrence_count\":2")); + Assert.IsTrue(json.Contains("\"isChild\":true")); + Assert.IsTrue(json.Contains("\"paths\"")); + Assert.IsTrue(json.Contains("\"schema.1\"")); + Assert.IsTrue(json.Contains("\"schema.3.schema.1\"")); + } + + [TestMethod] + public void Should_Deserialize_JSON_To_GlobalFieldRefs() + { + + var json = @"{ + ""uid"": ""referenced_global_field_uid"", + ""occurrence_count"": 2, + ""isChild"": true, + ""paths"": [""schema.1"", ""schema.3.schema.1""] + }"; + + + var globalFieldRefs = JsonConvert.DeserializeObject(json); + + Assert.IsNotNull(globalFieldRefs); + Assert.AreEqual("referenced_global_field_uid", globalFieldRefs.Uid); + Assert.AreEqual(2, globalFieldRefs.OccurrenceCount); + Assert.IsTrue(globalFieldRefs.IsChild); + Assert.IsNotNull(globalFieldRefs.Paths); + Assert.AreEqual(2, globalFieldRefs.Paths.Count); + Assert.AreEqual("schema.1", globalFieldRefs.Paths[0]); + Assert.AreEqual("schema.3.schema.1", globalFieldRefs.Paths[1]); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldRefs_With_Zero_OccurrenceCount() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "test_field", + OccurrenceCount = 0, + IsChild = false, + Paths = new List() + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"occurrence_count\":0")); + Assert.IsTrue(json.Contains("\"isChild\":false")); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldRefs_With_Large_OccurrenceCount() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "test_field", + OccurrenceCount = 100, + IsChild = true, + Paths = new List { "schema.0", "schema.1", "schema.2" } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"occurrence_count\":100")); + Assert.IsTrue(json.Contains("\"isChild\":true")); + Assert.IsTrue(json.Contains("\"schema.0\"")); + Assert.IsTrue(json.Contains("\"schema.1\"")); + Assert.IsTrue(json.Contains("\"schema.2\"")); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldRefs_With_Complex_Paths() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "complex_field", + OccurrenceCount = 3, + IsChild = true, + Paths = new List + { + "schema.1", + "schema.3.schema.4", + "schema.4.blocks.0.schema.2", + "schema.5.schema.1.schema.0" + } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"occurrence_count\":3")); + Assert.IsTrue(json.Contains("\"schema.1\"")); + Assert.IsTrue(json.Contains("\"schema.3.schema.4\"")); + Assert.IsTrue(json.Contains("\"schema.4.blocks.0.schema.2\"")); + Assert.IsTrue(json.Contains("\"schema.5.schema.1.schema.0\"")); + } + + [TestMethod] + public void Should_Deserialize_GlobalFieldRefs_With_Complex_Paths() + { + + var json = @"{ + ""uid"": ""complex_field"", + ""occurrence_count"": 3, + ""isChild"": true, + ""paths"": [ + ""schema.1"", + ""schema.3.schema.4"", + ""schema.4.blocks.0.schema.2"", + ""schema.5.schema.1.schema.0"" + ] + }"; + + + var globalFieldRefs = JsonConvert.DeserializeObject(json); + + Assert.IsNotNull(globalFieldRefs); + Assert.AreEqual("complex_field", globalFieldRefs.Uid); + Assert.AreEqual(3, globalFieldRefs.OccurrenceCount); + Assert.IsTrue(globalFieldRefs.IsChild); + Assert.IsNotNull(globalFieldRefs.Paths); + Assert.AreEqual(4, globalFieldRefs.Paths.Count); + Assert.AreEqual("schema.1", globalFieldRefs.Paths[0]); + Assert.AreEqual("schema.3.schema.4", globalFieldRefs.Paths[1]); + Assert.AreEqual("schema.4.blocks.0.schema.2", globalFieldRefs.Paths[2]); + Assert.AreEqual("schema.5.schema.1.schema.0", globalFieldRefs.Paths[3]); + } + + [TestMethod] + public void Should_Handle_GlobalFieldRefs_With_Null_Paths() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "test_field", + OccurrenceCount = 1, + IsChild = false, + Paths = null + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"paths\":null")); + } + + [TestMethod] + public void Should_Handle_GlobalFieldRefs_With_Empty_Paths() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "test_field", + OccurrenceCount = 1, + IsChild = false, + Paths = new List() + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"paths\":[]")); + } + + [TestMethod] + public void Should_Deserialize_GlobalFieldRefs_With_Null_Paths() + { + + var json = @"{ + ""uid"": ""test_field"", + ""occurrence_count"": 1, + ""isChild"": false, + ""paths"": null + }"; + + + var globalFieldRefs = JsonConvert.DeserializeObject(json); + + Assert.IsNotNull(globalFieldRefs); + Assert.AreEqual("test_field", globalFieldRefs.Uid); + Assert.AreEqual(1, globalFieldRefs.OccurrenceCount); + Assert.IsFalse(globalFieldRefs.IsChild); + Assert.IsNull(globalFieldRefs.Paths); + } + + [TestMethod] + public void Should_Deserialize_GlobalFieldRefs_With_Empty_Paths() + { + + var json = @"{ + ""uid"": ""test_field"", + ""occurrence_count"": 1, + ""isChild"": false, + ""paths"": [] + }"; + + + var globalFieldRefs = JsonConvert.DeserializeObject(json); + + Assert.IsNotNull(globalFieldRefs); + Assert.AreEqual("test_field", globalFieldRefs.Uid); + Assert.AreEqual(1, globalFieldRefs.OccurrenceCount); + Assert.IsFalse(globalFieldRefs.IsChild); + Assert.IsNotNull(globalFieldRefs.Paths); + Assert.AreEqual(0, globalFieldRefs.Paths.Count); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldRefs_With_Special_Characters_In_Uid() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "test-field_with_underscores.and.dots", + OccurrenceCount = 1, + IsChild = true, + Paths = new List { "schema.1" } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"uid\":\"test-field_with_underscores.and.dots\"")); + } + + [TestMethod] + public void Should_Deserialize_GlobalFieldRefs_With_Special_Characters_In_Uid() + { + + var json = @"{ + ""uid"": ""test-field_with_underscores.and.dots"", + ""occurrence_count"": 1, + ""isChild"": true, + ""paths"": [""schema.1""] + }"; + + + var globalFieldRefs = JsonConvert.DeserializeObject(json); + + Assert.IsNotNull(globalFieldRefs); + Assert.AreEqual("test-field_with_underscores.and.dots", globalFieldRefs.Uid); + Assert.AreEqual(1, globalFieldRefs.OccurrenceCount); + Assert.IsTrue(globalFieldRefs.IsChild); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldRefs_With_Unicode_Characters() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "test_field_中文", + OccurrenceCount = 1, + IsChild = false, + Paths = new List { "schema.1" } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"uid\":\"test_field_中文\"")); + } + + [TestMethod] + public void Should_Deserialize_GlobalFieldRefs_With_Unicode_Characters() + { + + var json = @"{ + ""uid"": ""test_field_中文"", + ""occurrence_count"": 1, + ""isChild"": false, + ""paths"": [""schema.1""] + }"; + + + var globalFieldRefs = JsonConvert.DeserializeObject(json); + + Assert.IsNotNull(globalFieldRefs); + Assert.AreEqual("test_field_中文", globalFieldRefs.Uid); + Assert.AreEqual(1, globalFieldRefs.OccurrenceCount); + Assert.IsFalse(globalFieldRefs.IsChild); + } + } +} \ No newline at end of file diff --git a/Contentstack.Management.Core.Unit.Tests/Models/GlobalFieldRefsTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/GlobalFieldRefsTest.cs new file mode 100644 index 0000000..0bde4ac --- /dev/null +++ b/Contentstack.Management.Core.Unit.Tests/Models/GlobalFieldRefsTest.cs @@ -0,0 +1,127 @@ +using System.Collections.Generic; +using AutoFixture; +using Contentstack.Management.Core.Models; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Newtonsoft.Json; + +namespace Contentstack.Management.Core.Unit.Tests.Models +{ + [TestClass] + public class GlobalFieldRefsTest + { + private readonly IFixture _fixture = new Fixture(); + + [TestMethod] + public void Should_Create_GlobalFieldRefs_With_All_Properties() + { + + var uid = _fixture.Create(); + var occurrenceCount = _fixture.Create(); + var isChild = _fixture.Create(); + var paths = new List { "schema.1", "schema.3.schema.4" }; + + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = uid, + OccurrenceCount = occurrenceCount, + IsChild = isChild, + Paths = paths + }; + + Assert.AreEqual(uid, globalFieldRefs.Uid); + Assert.AreEqual(occurrenceCount, globalFieldRefs.OccurrenceCount); + Assert.AreEqual(isChild, globalFieldRefs.IsChild); + Assert.AreEqual(paths, globalFieldRefs.Paths); + Assert.AreEqual(2, globalFieldRefs.Paths.Count); + } + + [TestMethod] + public void Should_Serialize_GlobalFieldRefs_Correctly() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "referenced_global_field", + OccurrenceCount = 3, + IsChild = true, + Paths = new List { "schema.1", "schema.3.schema.4", "schema.4.blocks.0.schema.2" } + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"uid\":\"referenced_global_field\"")); + Assert.IsTrue(json.Contains("\"occurrence_count\":3")); + Assert.IsTrue(json.Contains("\"isChild\":true")); + Assert.IsTrue(json.Contains("\"paths\"")); + Assert.IsTrue(json.Contains("schema.1")); + Assert.IsTrue(json.Contains("schema.3.schema.4")); + Assert.IsTrue(json.Contains("schema.4.blocks.0.schema.2")); + } + + [TestMethod] + public void Should_Deserialize_GlobalFieldRefs_Correctly() + { + + var json = @"{ + ""uid"": ""referenced_global_field"", + ""occurrence_count"": 2, + ""isChild"": false, + ""paths"": [""schema.1"", ""schema.2""] + }"; + + + var globalFieldRefs = JsonConvert.DeserializeObject(json); + + Assert.AreEqual("referenced_global_field", globalFieldRefs.Uid); + Assert.AreEqual(2, globalFieldRefs.OccurrenceCount); + Assert.IsFalse(globalFieldRefs.IsChild); + Assert.IsNotNull(globalFieldRefs.Paths); + Assert.AreEqual(2, globalFieldRefs.Paths.Count); + Assert.AreEqual("schema.1", globalFieldRefs.Paths[0]); + Assert.AreEqual("schema.2", globalFieldRefs.Paths[1]); + } + + [TestMethod] + public void Should_Handle_Null_Paths() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "test_uid", + OccurrenceCount = 1, + IsChild = false, + Paths = null + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"uid\":\"test_uid\"")); + Assert.IsTrue(json.Contains("\"occurrence_count\":1")); + Assert.IsTrue(json.Contains("\"isChild\":false")); + } + + [TestMethod] + public void Should_Handle_Empty_Paths() + { + + var globalFieldRefs = new GlobalFieldRefs + { + Uid = "test_uid", + OccurrenceCount = 0, + IsChild = true, + Paths = new List() + }; + + + var json = JsonConvert.SerializeObject(globalFieldRefs); + + Assert.IsTrue(json.Contains("\"uid\":\"test_uid\"")); + Assert.IsTrue(json.Contains("\"occurrence_count\":0")); + Assert.IsTrue(json.Contains("\"isChild\":true")); + Assert.IsTrue(json.Contains("\"paths\":[]")); + } + } +} \ No newline at end of file diff --git a/Contentstack.Management.Core.Unit.Tests/Services/BulkOperationServicesTest.cs b/Contentstack.Management.Core.Unit.Tests/Services/BulkOperationServicesTest.cs index 35e7705..01c6b51 100644 --- a/Contentstack.Management.Core.Unit.Tests/Services/BulkOperationServicesTest.cs +++ b/Contentstack.Management.Core.Unit.Tests/Services/BulkOperationServicesTest.cs @@ -25,7 +25,7 @@ public void Setup() [TestMethod] public void Test001_BulkReleaseItemsService_Initialization() { - // Arrange + var releaseData = new BulkReleaseItemsData { Release = "release_uid", @@ -45,10 +45,9 @@ public void Test001_BulkReleaseItemsService_Initialization() } }; - // Act + var service = new BulkReleaseItemsService(_serializer, _stack, releaseData, "1.0"); - // Assert Assert.IsNotNull(service); Assert.AreEqual("/bulk/release/items", service.ResourcePath); Assert.AreEqual("POST", service.HttpMethod); @@ -59,7 +58,7 @@ public void Test001_BulkReleaseItemsService_Initialization() [TestMethod] public void Test002_BulkReleaseItemsService_ContentBody() { - // Arrange + var releaseData = new BulkReleaseItemsData { Release = "release_uid", @@ -81,10 +80,9 @@ public void Test002_BulkReleaseItemsService_ContentBody() var service = new BulkReleaseItemsService(_serializer, _stack, releaseData); - // Act + service.ContentBody(); - // Assert Assert.IsNotNull(service.ByteContent); Assert.IsTrue(service.ByteContent.Length > 0); @@ -99,7 +97,7 @@ public void Test002_BulkReleaseItemsService_ContentBody() [TestMethod] public void Test003_BulkReleaseItemsService_Without_BulkVersion() { - // Arrange + var releaseData = new BulkReleaseItemsData { Release = "release_uid", @@ -109,10 +107,9 @@ public void Test003_BulkReleaseItemsService_Without_BulkVersion() Items = new List() }; - // Act + var service = new BulkReleaseItemsService(_serializer, _stack, releaseData); - // Assert Assert.IsNotNull(service); Assert.AreEqual("/bulk/release/items", service.ResourcePath); Assert.AreEqual("POST", service.HttpMethod); @@ -122,7 +119,7 @@ public void Test003_BulkReleaseItemsService_Without_BulkVersion() [TestMethod] public void Test004_BulkPublishService_Initialization() { - // Arrange + var publishDetails = new BulkPublishDetails { Entries = new List @@ -139,10 +136,9 @@ public void Test004_BulkPublishService_Initialization() Environments = new List { "env1" } }; - // Act + var service = new BulkPublishService(_serializer, _stack, publishDetails, true, true, true); - // Assert Assert.IsNotNull(service); Assert.AreEqual("/bulk/publish", service.ResourcePath); Assert.AreEqual("POST", service.HttpMethod); @@ -155,7 +151,7 @@ public void Test004_BulkPublishService_Initialization() [TestMethod] public void Test005_BulkPublishService_ContentBody() { - // Arrange + var publishDetails = new BulkPublishDetails { Entries = new List @@ -174,10 +170,9 @@ public void Test005_BulkPublishService_ContentBody() var service = new BulkPublishService(_serializer, _stack, publishDetails); - // Act + service.ContentBody(); - // Assert Assert.IsNotNull(service.ByteContent); Assert.IsTrue(service.ByteContent.Length > 0); @@ -190,7 +185,7 @@ public void Test005_BulkPublishService_ContentBody() [TestMethod] public void Test006_BulkPublishService_With_All_Flags() { - // Arrange + var publishDetails = new BulkPublishDetails { Entries = new List(), @@ -198,10 +193,9 @@ public void Test006_BulkPublishService_With_All_Flags() Environments = new List { "env1" } }; - // Act + var service = new BulkPublishService(_serializer, _stack, publishDetails, true, true, true); - // Assert Assert.IsNotNull(service); Assert.IsTrue(service.Headers.ContainsKey("skip_workflow_stage_check")); Assert.IsTrue(service.Headers.ContainsKey("approvals")); @@ -212,7 +206,7 @@ public void Test006_BulkPublishService_With_All_Flags() [TestMethod] public void Test007_BulkPublishService_Without_Flags() { - // Arrange + var publishDetails = new BulkPublishDetails { Entries = new List(), @@ -220,10 +214,9 @@ public void Test007_BulkPublishService_Without_Flags() Environments = new List { "env1" } }; - // Act + var service = new BulkPublishService(_serializer, _stack, publishDetails, false, false, false); - // Assert Assert.IsNotNull(service); Assert.IsFalse(service.Headers.ContainsKey("skip_workflow_stage_check")); Assert.IsFalse(service.Headers.ContainsKey("approvals")); @@ -232,7 +225,7 @@ public void Test007_BulkPublishService_Without_Flags() [TestMethod] public void Test008_BulkUnpublishService_Initialization() { - // Arrange + var unpublishDetails = new BulkPublishDetails { Entries = new List @@ -249,10 +242,9 @@ public void Test008_BulkUnpublishService_Initialization() Environments = new List { "env1" } }; - // Act + var service = new BulkUnpublishService(_serializer, _stack, unpublishDetails, true, true, true); - // Assert Assert.IsNotNull(service); Assert.AreEqual("/bulk/unpublish", service.ResourcePath); Assert.AreEqual("POST", service.HttpMethod); @@ -263,7 +255,7 @@ public void Test008_BulkUnpublishService_Initialization() [TestMethod] public void Test009_BulkUnpublishService_ContentBody() { - // Arrange + var unpublishDetails = new BulkPublishDetails { Entries = new List @@ -282,10 +274,9 @@ public void Test009_BulkUnpublishService_ContentBody() var service = new BulkUnpublishService(_serializer, _stack, unpublishDetails); - // Act + service.ContentBody(); - // Assert Assert.IsNotNull(service.ByteContent); Assert.IsTrue(service.ByteContent.Length > 0); @@ -298,7 +289,7 @@ public void Test009_BulkUnpublishService_ContentBody() [TestMethod] public void Test010_BulkDeleteService_Initialization() { - // Arrange + var deleteDetails = new BulkDeleteDetails { Entries = new List @@ -316,10 +307,9 @@ public void Test010_BulkDeleteService_Initialization() } }; - // Act + var service = new BulkDeleteService(_serializer, _stack, deleteDetails); - // Assert Assert.IsNotNull(service); Assert.AreEqual("/bulk/delete", service.ResourcePath); Assert.AreEqual("POST", service.HttpMethod); @@ -328,7 +318,7 @@ public void Test010_BulkDeleteService_Initialization() [TestMethod] public void Test011_BulkDeleteService_ContentBody() { - // Arrange + var deleteDetails = new BulkDeleteDetails { Entries = new List @@ -348,10 +338,9 @@ public void Test011_BulkDeleteService_ContentBody() var service = new BulkDeleteService(_serializer, _stack, deleteDetails); - // Act + service.ContentBody(); - // Assert Assert.IsNotNull(service.ByteContent); Assert.IsTrue(service.ByteContent.Length > 0); @@ -363,7 +352,7 @@ public void Test011_BulkDeleteService_ContentBody() [TestMethod] public void Test012_BulkWorkflowUpdateService_Initialization() { - // Arrange + var updateBody = new BulkWorkflowUpdateBody { Entries = new List @@ -384,10 +373,9 @@ public void Test012_BulkWorkflowUpdateService_Initialization() } }; - // Act + var service = new BulkWorkflowUpdateService(_serializer, _stack, updateBody); - // Assert Assert.IsNotNull(service); Assert.AreEqual("/bulk/workflow", service.ResourcePath); Assert.AreEqual("POST", service.HttpMethod); @@ -396,7 +384,7 @@ public void Test012_BulkWorkflowUpdateService_Initialization() [TestMethod] public void Test013_BulkWorkflowUpdateService_ContentBody() { - // Arrange + var updateBody = new BulkWorkflowUpdateBody { Entries = new List @@ -419,10 +407,9 @@ public void Test013_BulkWorkflowUpdateService_ContentBody() var service = new BulkWorkflowUpdateService(_serializer, _stack, updateBody); - // Act + service.ContentBody(); - // Assert Assert.IsNotNull(service.ByteContent); Assert.IsTrue(service.ByteContent.Length > 0); @@ -434,14 +421,13 @@ public void Test013_BulkWorkflowUpdateService_ContentBody() [TestMethod] public void Test014_BulkJobStatusService_Initialization() { - // Arrange + string jobId = "test_job_id"; string bulkVersion = "1.0"; - // Act + var service = new BulkJobStatusService(_serializer, _stack, jobId, bulkVersion); - // Assert Assert.IsNotNull(service); Assert.AreEqual($"/bulk/jobs/{jobId}", service.ResourcePath); Assert.AreEqual("GET", service.HttpMethod); @@ -452,13 +438,12 @@ public void Test014_BulkJobStatusService_Initialization() [TestMethod] public void Test015_BulkJobStatusService_Without_BulkVersion() { - // Arrange + string jobId = "test_job_id"; - // Act + var service = new BulkJobStatusService(_serializer, _stack, jobId); - // Assert Assert.IsNotNull(service); Assert.AreEqual($"/bulk/jobs/{jobId}", service.ResourcePath); Assert.AreEqual("GET", service.HttpMethod); @@ -468,7 +453,7 @@ public void Test015_BulkJobStatusService_Without_BulkVersion() [TestMethod] public void Test016_BulkAddItemsService_Initialization() { - // Arrange + var addItemsData = new BulkAddItemsData { Items = new List @@ -481,10 +466,9 @@ public void Test016_BulkAddItemsService_Initialization() } }; - // Act + var service = new BulkAddItemsService(_serializer, _stack, addItemsData, "1.0"); - // Assert Assert.IsNotNull(service); Assert.AreEqual("/bulk/release/items", service.ResourcePath); Assert.AreEqual("POST", service.HttpMethod); @@ -495,7 +479,7 @@ public void Test016_BulkAddItemsService_Initialization() [TestMethod] public void Test017_BulkUpdateItemsService_Initialization() { - // Arrange + var updateItemsData = new BulkAddItemsData { Items = new List @@ -508,10 +492,9 @@ public void Test017_BulkUpdateItemsService_Initialization() } }; - // Act + var service = new BulkUpdateItemsService(_serializer, _stack, updateItemsData, "1.0"); - // Assert Assert.IsNotNull(service); Assert.AreEqual("/bulk/release/update_items", service.ResourcePath); Assert.AreEqual("PUT", service.HttpMethod); @@ -522,7 +505,7 @@ public void Test017_BulkUpdateItemsService_Initialization() [TestMethod] public void Test018_BulkReleaseItemsService_Null_Data_Throws_Exception() { - // Arrange & Act & Assert + Assert.ThrowsException(() => { new BulkReleaseItemsService(_serializer, _stack, null); @@ -532,7 +515,7 @@ public void Test018_BulkReleaseItemsService_Null_Data_Throws_Exception() [TestMethod] public void Test019_BulkPublishService_Null_Data_Throws_Exception() { - // Arrange & Act & Assert + Assert.ThrowsException(() => { new BulkPublishService(_serializer, _stack, null); @@ -542,7 +525,7 @@ public void Test019_BulkPublishService_Null_Data_Throws_Exception() [TestMethod] public void Test020_BulkDeleteService_Null_Data_Throws_Exception() { - // Arrange & Act & Assert + Assert.ThrowsException(() => { new BulkDeleteService(_serializer, _stack, null); diff --git a/Contentstack.Management.Core/Models/ContentModelling.cs b/Contentstack.Management.Core/Models/ContentModelling.cs index c3b0cdf..90a9700 100644 --- a/Contentstack.Management.Core/Models/ContentModelling.cs +++ b/Contentstack.Management.Core/Models/ContentModelling.cs @@ -13,12 +13,18 @@ public class ContentModelling [JsonProperty(propertyName: "uid")] public string Uid { get; set; } + [JsonProperty(propertyName: "description")] + public string Description { get; set; } + [JsonProperty(propertyName: "field_rules")] public List FieldRules { get; set; } [JsonProperty(propertyName: "schema")] public List Schema { get; set; } + [JsonProperty(propertyName: "global_field_refs")] + public List GlobalFieldRefs { get; set; } + [JsonProperty(propertyName: "options")] public Option Options { get; set; } } diff --git a/Contentstack.Management.Core/Models/Fields/GlobalFieldReference.cs b/Contentstack.Management.Core/Models/Fields/GlobalFieldReference.cs new file mode 100644 index 0000000..0e5b9b6 --- /dev/null +++ b/Contentstack.Management.Core/Models/Fields/GlobalFieldReference.cs @@ -0,0 +1,42 @@ +using System; +using Newtonsoft.Json; + +namespace Contentstack.Management.Core.Models.Fields +{ + /// + /// Represents a global field reference in a schema. + /// This field type allows referencing other global fields within a global field schema. + /// + public class GlobalFieldReference : Field + { + /// + /// The UID of the global field being referenced. + /// + [JsonProperty(propertyName: "reference_to")] + public string ReferenceTo { get; set; } + + /// + /// Determines if this field can accept multiple values. + /// + [JsonProperty(propertyName: "multiple")] + public new bool Multiple { get; set; } + + /// + /// Determines if this field is mandatory. + /// + [JsonProperty(propertyName: "mandatory")] + public new bool Mandatory { get; set; } + + /// + /// Determines if this field value must be unique. + /// + [JsonProperty(propertyName: "unique")] + public new bool Unique { get; set; } + + /// + /// Determines if this field is non-localizable. + /// + [JsonProperty(propertyName: "non_localizable")] + public bool NonLocalizable { get; set; } + } +} \ No newline at end of file diff --git a/Contentstack.Management.Core/Models/GlobalFieldRefs.cs b/Contentstack.Management.Core/Models/GlobalFieldRefs.cs new file mode 100644 index 0000000..ea9de95 --- /dev/null +++ b/Contentstack.Management.Core/Models/GlobalFieldRefs.cs @@ -0,0 +1,36 @@ +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace Contentstack.Management.Core.Models +{ + /// + /// Represents a global field reference tracking information. + /// This is used to track references to other global fields within a global field schema. + /// + public class GlobalFieldRefs + { + /// + /// The UID of the referenced global field. + /// + [JsonProperty(propertyName: "uid")] + public string Uid { get; set; } + + /// + /// The number of times this global field is referenced in the schema. + /// + [JsonProperty(propertyName: "occurrence_count")] + public int OccurrenceCount { get; set; } + + /// + /// Indicates whether this is a child reference. + /// + [JsonProperty(propertyName: "isChild")] + public bool IsChild { get; set; } + + /// + /// Array of paths where this global field reference occurs in the schema. + /// + [JsonProperty(propertyName: "paths")] + public List Paths { get; set; } + } +} \ No newline at end of file From 56990d721bf70553126991cd0e3fd43df4dcbd87 Mon Sep 17 00:00:00 2001 From: raj pandey Date: Thu, 17 Jul 2025 13:06:33 +0530 Subject: [PATCH 2/2] Version Bump and Change Log --- CHANGELOG.md | 8 ++++++++ Contentstack.Management.Core/ContentstackClient.cs | 2 +- Directory.Build.props | 2 +- 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 40509e9..26a29a4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,11 @@ +# Changelog +## [v0.3.0](https://github.com/contentstack/contentstack-management-dotnet/tree/v0.3.0) + - Feat + - Bulk Operations: + - Added Support for the bulk operations of Publish, Unpublish, Delete, Workflow Update, addRelease Items, Update Release Items, Job-Status both sync and async methods + - Nested Global Fields: + Added the support for the nested global fields for all the CRUD Operations + # Changelog ## [v0.2.0](https://github.com/contentstack/contentstack-management-dotnet/tree/v0.2.0) - Fix diff --git a/Contentstack.Management.Core/ContentstackClient.cs b/Contentstack.Management.Core/ContentstackClient.cs index 6425b22..876bf85 100644 --- a/Contentstack.Management.Core/ContentstackClient.cs +++ b/Contentstack.Management.Core/ContentstackClient.cs @@ -35,7 +35,7 @@ public class ContentstackClient : IContentstackClient private HttpClient _httpClient; private bool _disposed = false; - private string Version => "0.2.0"; + private string Version => "0.3.0"; private string xUserAgent => $"contentstack-management-dotnet/{Version}"; #endregion diff --git a/Directory.Build.props b/Directory.Build.props index 15aebe4..96b2414 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -1,5 +1,5 @@ - 0.2.0 + 0.3.0