feat: Add full Taxonomy and Terms API to .NET CMA SDK

Contentstack.Management.Core.Tests/IntegrationTest/Contentstack017_TaxonomyTest.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Threading.Tasks;
+using Contentstack.Management.Core.Exceptions;
+using Contentstack.Management.Core.Models;
+using Contentstack.Management.Core.Tests.Model;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Contentstack.Management.Core.Tests.IntegrationTest
+{
+    [TestClass]
+    public class Contentstack017_TaxonomyTest
+    {
+        private static string _taxonomyUid;
+        private Stack _stack;
+        private TaxonomyModel _createModel;
+
+        [TestInitialize]
+        public void Initialize()
+        {
+            StackResponse response = StackResponse.getStack(Contentstack.Client.serializer);
+            _stack = Contentstack.Client.Stack(response.Stack.APIKey);
+            if (_taxonomyUid == null)
+                _taxonomyUid = "taxonomy_integration_test_" + Guid.NewGuid().ToString("N").Substring(0, 8);
+            _createModel = new TaxonomyModel
+            {
+                Uid = _taxonomyUid,
+                Name = "Taxonomy Integration Test",
+                Description = "Description for taxonomy integration test"
+            };
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test001_Should_Create_Taxonomy()
+        {
+            ContentstackResponse response = _stack.Taxonomy().Create(_createModel);
+            Assert.IsTrue(response.IsSuccessStatusCode, $"Create failed: {response.OpenResponse()}");
+
+            var wrapper = response.OpenTResponse<TaxonomyResponseModel>();
+            Assert.IsNotNull(wrapper?.Taxonomy);
+            Assert.AreEqual(_createModel.Uid, wrapper.Taxonomy.Uid);
+            Assert.AreEqual(_createModel.Name, wrapper.Taxonomy.Name);
+            Assert.AreEqual(_createModel.Description, wrapper.Taxonomy.Description);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test002_Should_Fetch_Taxonomy()
+        {
+            ContentstackResponse response = _stack.Taxonomy(_taxonomyUid).Fetch();
+            Assert.IsTrue(response.IsSuccessStatusCode, $"Fetch failed: {response.OpenResponse()}");
+
+            var wrapper = response.OpenTResponse<TaxonomyResponseModel>();
+            Assert.IsNotNull(wrapper?.Taxonomy);
+            Assert.AreEqual(_taxonomyUid, wrapper.Taxonomy.Uid);
+            Assert.IsNotNull(wrapper.Taxonomy.Name);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test003_Should_Query_Taxonomies()
+        {
+            ContentstackResponse response = _stack.Taxonomy().Query().Find();
+            Assert.IsTrue(response.IsSuccessStatusCode, $"Query failed: {response.OpenResponse()}");
+
+            var wrapper = response.OpenTResponse<TaxonomiesResponseModel>();
+            Assert.IsNotNull(wrapper?.Taxonomies);
+            Assert.IsTrue(wrapper.Taxonomies.Count >= 0);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test004_Should_Update_Taxonomy()
+        {
+            var updateModel = new TaxonomyModel
+            {
+                Name = "Taxonomy Integration Test Updated",
+                Description = "Updated description"
+            };
+            ContentstackResponse response = _stack.Taxonomy(_taxonomyUid).Update(updateModel);
+            Assert.IsTrue(response.IsSuccessStatusCode, $"Update failed: {response.OpenResponse()}");
+
+            var wrapper = response.OpenTResponse<TaxonomyResponseModel>();
+            Assert.IsNotNull(wrapper?.Taxonomy);
+            Assert.AreEqual("Taxonomy Integration Test Updated", wrapper.Taxonomy.Name);
+            Assert.AreEqual("Updated description", wrapper.Taxonomy.Description);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test005_Should_Fetch_Taxonomy_Async()
+        {
+            ContentstackResponse response = await _stack.Taxonomy(_taxonomyUid).FetchAsync();
+            Assert.IsTrue(response.IsSuccessStatusCode, $"FetchAsync failed: {response.OpenResponse()}");
+
+            var wrapper = response.OpenTResponse<TaxonomyResponseModel>();
+            Assert.IsNotNull(wrapper?.Taxonomy);
+            Assert.AreEqual(_taxonomyUid, wrapper.Taxonomy.Uid);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test006_Should_Delete_Taxonomy()
+        {
+            ContentstackResponse response = _stack.Taxonomy(_taxonomyUid).Delete();
+            Assert.IsTrue(response.IsSuccessStatusCode, $"Delete failed: {response.OpenResponse()}");
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test007_Should_Throw_When_Fetch_NonExistent_Taxonomy()
+        {
+            Assert.ThrowsException<ContentstackErrorException>(() =>
+                _stack.Taxonomy("non_existent_taxonomy_uid_12345").Fetch());
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test008_Should_Throw_When_Delete_NonExistent_Taxonomy()
+        {
+            Assert.ThrowsException<ContentstackErrorException>(() =>
+                _stack.Taxonomy("non_existent_taxonomy_uid_12345").Delete());
+        }
+    }
+}

Contentstack.Management.Core.Tests/Model/Models.cs

@@ -1,4 +1,4 @@
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Contentstack.Management.Core.Models;
 using System.Collections.Generic;
 
@@ -25,5 +25,17 @@ public class ContentTypesModel
         [JsonProperty("content_types")]
         public List<ContentModelling> Modellings { get; set; }
     }
+
+    public class TaxonomyResponseModel
+    {
+        [JsonProperty("taxonomy")]
+        public TaxonomyModel Taxonomy { get; set; }
+    }
+
+    public class TaxonomiesResponseModel
+    {
+        [JsonProperty("taxonomies")]
+        public List<TaxonomyModel> Taxonomies { get; set; }
+    }
 }
 

Contentstack.Management.Core.Unit.Tests/Models/TaxonomyImportModelTest.cs

@@ -0,0 +1,32 @@
+using System;
+using System.IO;
+using Contentstack.Management.Core.Models;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Contentstack.Management.Core.Unit.Tests.Models
+{
+    [TestClass]
+    public class TaxonomyImportModelTest
+    {
+        [TestMethod]
+        public void Throws_When_FilePath_Is_Null()
+        {
+            var ex = Assert.ThrowsException<ArgumentNullException>(() => new TaxonomyImportModel((string)null));
+            Assert.AreEqual("filePath", ex.ParamName);
+        }
+
+        [TestMethod]
+        public void Throws_When_FilePath_Is_Empty()
+        {
+            var ex = Assert.ThrowsException<ArgumentNullException>(() => new TaxonomyImportModel(""));
+            Assert.AreEqual("filePath", ex.ParamName);
+        }
+
+        [TestMethod]
+        public void Throws_When_Stream_Is_Null()
+        {
+            var ex = Assert.ThrowsException<ArgumentNullException>(() => new TaxonomyImportModel((Stream)null, "taxonomy.json"));
+            Assert.AreEqual("stream", ex.ParamName);
+        }
+    }
+}

Contentstack.Management.Core.Unit.Tests/Models/TaxonomyTest.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Net;
+using AutoFixture;
+using Contentstack.Management.Core.Models;
+using Contentstack.Management.Core.Queryable;
+using Contentstack.Management.Core.Unit.Tests.Mokes;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+
+namespace Contentstack.Management.Core.Unit.Tests.Models
+{
+    [TestClass]
+    public class TaxonomyTest
+    {
+        private Stack _stack;
+        private readonly IFixture _fixture = new Fixture();
+        private ContentstackResponse _contentstackResponse;
+
+        [TestInitialize]
+        public void Initialize()
+        {
+            var client = new ContentstackClient();
+            _contentstackResponse = MockResponse.CreateContentstackResponse("MockResponse.txt");
+            client.ContentstackPipeline.ReplaceHandler(new MockHttpHandler(_contentstackResponse));
+            client.contentstackOptions.Authtoken = _fixture.Create<string>();
+            _stack = new Stack(client, _fixture.Create<string>());
+        }
+
+        [TestMethod]
+        public void Initialize_Taxonomy()
+        {
+            Taxonomy taxonomy = _stack.Taxonomy();
+
+            Assert.IsNull(taxonomy.Uid);
+            Assert.AreEqual("/taxonomies", taxonomy.resourcePath);
+            Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Fetch());
+            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => taxonomy.FetchAsync());
+            Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Update(_fixture.Create<TaxonomyModel>()));
+            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => taxonomy.UpdateAsync(_fixture.Create<TaxonomyModel>()));
+            Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Delete());
+            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => taxonomy.DeleteAsync());
+            Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Terms());
+            Assert.AreEqual(typeof(Query), taxonomy.Query().GetType());
+        }
+
+        [TestMethod]
+        public void Initialize_Taxonomy_With_Uid()
+        {
+            string uid = _fixture.Create<string>();
+            Taxonomy taxonomy = _stack.Taxonomy(uid);
+
+            Assert.AreEqual(uid, taxonomy.Uid);
+            Assert.AreEqual($"/taxonomies/{uid}", taxonomy.resourcePath);
+            Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Create(_fixture.Create<TaxonomyModel>()));
+            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => taxonomy.CreateAsync(_fixture.Create<TaxonomyModel>()));
+            Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Query());
+        }
+
+        [TestMethod]
+        public void Should_Create_Taxonomy()
+        {
+            ContentstackResponse response = _stack.Taxonomy().Create(_fixture.Create<TaxonomyModel>());
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public async System.Threading.Tasks.Task Should_Create_Taxonomy_Async()
+        {
+            ContentstackResponse response = await _stack.Taxonomy().CreateAsync(_fixture.Create<TaxonomyModel>());
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public void Should_Query_Taxonomy()
+        {
+            ContentstackResponse response = _stack.Taxonomy().Query().Find();
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public async System.Threading.Tasks.Task Should_Query_Taxonomy_Async()
+        {
+            ContentstackResponse response = await _stack.Taxonomy().Query().FindAsync();
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public void Should_Fetch_Taxonomy()
+        {
+            ContentstackResponse response = _stack.Taxonomy(_fixture.Create<string>()).Fetch();
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public async System.Threading.Tasks.Task Should_Fetch_Taxonomy_Async()
+        {
+            ContentstackResponse response = await _stack.Taxonomy(_fixture.Create<string>()).FetchAsync();
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public void Should_Get_Terms_From_Taxonomy()
+        {
+            string taxonomyUid = _fixture.Create<string>();
+            Term terms = _stack.Taxonomy(taxonomyUid).Terms();
+
+            Assert.IsNotNull(terms);
+            Assert.IsNull(terms.Uid);
+            Assert.AreEqual($"/taxonomies/{taxonomyUid}/terms", terms.resourcePath);
+        }
+
+        [TestMethod]
+        public void Should_Get_Single_Term_From_Taxonomy()
+        {
+            string taxonomyUid = _fixture.Create<string>();
+            string termUid = _fixture.Create<string>();
+            Term term = _stack.Taxonomy(taxonomyUid).Terms(termUid);
+
+            Assert.IsNotNull(term);
+            Assert.AreEqual(termUid, term.Uid);
+            Assert.AreEqual($"/taxonomies/{taxonomyUid}/terms/{termUid}", term.resourcePath);
+        }
+
+        [TestMethod]
+        public void Export_Throws_When_Uid_Is_Empty()
+        {
+            Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy().Export());
+            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy().ExportAsync());
+        }
+
+        [TestMethod]
+        public void Locales_Throws_When_Uid_Is_Empty()
+        {
+            Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy().Locales());
+            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy().LocalesAsync());
+        }
+
+        [TestMethod]
+        public void Localize_Throws_When_Uid_Is_Empty()
+        {
+            Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy().Localize(_fixture.Create<TaxonomyModel>()));
+            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy().LocalizeAsync(_fixture.Create<TaxonomyModel>()));
+        }
+
+        [TestMethod]
+        public void Import_Throws_When_Uid_Is_Set()
+        {
+            using (var stream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes("{}")))
+            {
+                var model = new TaxonomyImportModel(stream, "taxonomy.json");
+                Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy("some_uid").Import(model));
+                Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy("some_uid").ImportAsync(model));
+            }
+        }
+
+        [TestMethod]
+        public void Create_Throws_When_Uid_Is_Set()
+        {
+            Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy(_fixture.Create<string>()).Create(_fixture.Create<TaxonomyModel>()));
+            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy(_fixture.Create<string>()).CreateAsync(_fixture.Create<TaxonomyModel>()));
+        }
+
+        [TestMethod]
+        public void Query_Throws_When_Uid_Is_Set()
+        {
+            Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy(_fixture.Create<string>()).Query());
+        }
+
+        [TestMethod]
+        public void Localize_When_Api_Returns_400_Returns_Unsuccessful_Response()
+        {
+            var httpMsg = MockResponse.Create(HttpStatusCode.BadRequest, null, "{\"error_message\":\"Invalid locale\",\"error_code\":400}");
+            var badResponse = new ContentstackResponse(httpMsg, JsonSerializer.Create(new JsonSerializerSettings()));
+            var client = new ContentstackClient();
+            client.ContentstackPipeline.ReplaceHandler(new MockHttpHandler(badResponse));
+            client.contentstackOptions.Authtoken = _fixture.Create<string>();
+            var stack = new Stack(client, _fixture.Create<string>());
+            string uid = _fixture.Create<string>();
+
+            ContentstackResponse response = stack.Taxonomy(uid).Localize(_fixture.Create<TaxonomyModel>());
+
+            Assert.IsFalse(response.IsSuccessStatusCode);
+            Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+    }
+}