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

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,32 @@ 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; }
+    }
+
+    public class TermResponseModel
+    {
+        [JsonProperty("term")]
+        public TermModel Term { get; set; }
+    }
+
+    public class TermsResponseModel
+    {
+        [JsonProperty("terms")]
+        public List<TermModel> Terms { get; set; }
+
+        [JsonProperty("count")]
+        public int? Count { 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);
+        }
+    }
+}