staging PR

.github/workflows/sca-scan.yml

@@ -17,3 +17,6 @@ jobs:
           SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
         with:
           args: --file=Contentstack.Management.Core/obj/project.assets.json --fail-on=all
+          json: true
+        continue-on-error: true
+      - uses: contentstack/sca-policy@main

.gitignore

@@ -24,4 +24,7 @@ packages/
 */mono**
 */appSettings.json
 api_referece/*
-.sonarqube/
+.sonarqube/
+*.html
+*.cobertura.xml
+integration-test-report_*.html

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [v0.7.0](https://github.com/contentstack/contentstack-management-dotnet/tree/v0.7.0)
+ - Feat
+   - **Bulk publish/unpublish: query parameters (DX-3233)**
+     - `skip_workflow_stage_check` and `approvals` are now sent as query parameters instead of headers for bulk publish and bulk unpublish
+     - Unit tests updated to assert on `QueryResources` for these flags (BulkPublishServiceTest, BulkUnpublishServiceTest, BulkOperationServicesTest)
+     - Integration tests: bulk publish with skipWorkflowStage and approvals (Test003a), bulk unpublish with skipWorkflowStage and approvals (Test004a), and helper `EnsureBulkTestContentTypeAndEntriesAsync()` so bulk tests can run in any order
+
 ## [v0.6.1](https://github.com/contentstack/contentstack-management-dotnet/tree/v0.6.1) (2026-02-02)
  - Fix
    - Release DELETE request no longer includes Content-Type header to comply with API requirements

Contentstack.Management.Core.Tests/Contentstack.Management.Core.Tests.csproj

@@ -1,49 +1,55 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
-
-    <IsPackable>false</IsPackable>
-    <ReleaseVersion>$(Version)</ReleaseVersion>
-
-    <SignAssembly>true</SignAssembly>
-    <AssemblyOriginatorKeyFile>../CSManagementSDK.snk</AssemblyOriginatorKeyFile>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.8.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.8.2" />
-    <PackageReference Include="coverlet.collector" Version="6.0.4"><IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-<PrivateAssets>all</PrivateAssets>
-</PackageReference>
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="9.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="9.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.2" />
-    <PackageReference Include="AutoFixture" Version="4.18.1" />
-    <PackageReference Include="AutoFixture.AutoMoq" Version="4.18.1" />
-    <PackageReference Include="Moq" Version="4.20.72" />
-    <PackageReference Include="Microsoft.AspNetCore.Http" Version="2.3.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="IntegrationTest\" />
-    <Folder Include="Model\" />
-    <Folder Include="Mock\" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Include="Mock\*.json" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="appsettings.json">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-  <ItemGroup>
-    <None Remove="Microsoft.AspNetCore.Http" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Contentstack.Management.Core\contentstack.management.core.csproj" />
-  </ItemGroup>
-</Project>
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+    <ReleaseVersion>$(Version)</ReleaseVersion>
+
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>../CSManagementSDK.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.8.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.8.2" />
+    <PackageReference Include="coverlet.collector" Version="6.0.4"><IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+<PrivateAssets>all</PrivateAssets>
+</PackageReference>
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="9.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="9.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.2" />
+    <PackageReference Include="AutoFixture" Version="4.18.1" />
+    <PackageReference Include="AutoFixture.AutoMoq" Version="4.18.1" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="Microsoft.AspNetCore.Http" Version="2.3.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+    <PackageReference Include="System.Text.RegularExpressions" Version="4.3.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Helpers\" />
+    <Folder Include="IntegrationTest\" />
+    <Folder Include="Model\" />
+    <Folder Include="Mock\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="Mock\*.json" />
+  </ItemGroup>
+
+  <ItemGroup>
+       <Content Include="appSettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Remove="Microsoft.AspNetCore.Http" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Contentstack.Management.Core\contentstack.management.core.csproj" />
+  </ItemGroup>
+</Project>

Contentstack.Management.Core.Tests/Contentstack.cs

@@ -1,9 +1,11 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net;
+using System.Net.Http;
 using System.Reflection;
+using Contentstack.Management.Core.Tests.Helpers;
 using Contentstack.Management.Core.Tests.Model;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Options;
@@ -14,15 +16,6 @@ namespace Contentstack.Management.Core.Tests
 {
     public class Contentstack
     {
-        private static readonly Lazy<ContentstackClient>
-        client =
-        new Lazy<ContentstackClient>(() =>
-        {
-            ContentstackClientOptions options = Config.GetSection("Contentstack").Get<ContentstackClientOptions>();
-            return new ContentstackClient(new OptionsWrapper<ContentstackClientOptions>(options));
-        });
-
-
         private static readonly Lazy<IConfigurationRoot>
         config =
         new Lazy<IConfigurationRoot>(() =>
@@ -42,13 +35,28 @@ private static readonly Lazy<IConfigurationRoot>
             return Config.GetSection("Contentstack:Organization").Get<OrganizationModel>();
         });
 
-        public static ContentstackClient Client { get { return client.Value; } }
         public static IConfigurationRoot Config{ get { return config.Value; } }
         public static NetworkCredential Credential { get { return credential.Value; } }
         public static OrganizationModel Organization { get { return organization.Value; } }
 
         public static StackModel Stack { get; set; }
 
+        /// <summary>
+        /// Creates a new ContentstackClient, logs in via the Login API (never from config),
+        /// and returns the authenticated client. Callers are responsible for calling Logout()
+        /// when done.
+        /// </summary>
+        public static ContentstackClient CreateAuthenticatedClient()
+        {
+            ContentstackClientOptions options = Config.GetSection("Contentstack").Get<ContentstackClientOptions>();
+            options.Authtoken = null;
+            var handler = new LoggingHttpHandler();
+            var httpClient = new HttpClient(handler);
+            var client = new ContentstackClient(httpClient, options);
+            client.Login(Credential);
+            return client;
+        }
+
         public static T serialize<T>(JsonSerializer serializer, string filePath)
         {
             string response = GetResourceText(filePath);

Contentstack.Management.Core.Tests/Helpers/AssertLogger.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using Contentstack.Management.Core.Exceptions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Contentstack.Management.Core.Tests.Helpers
+{
+    public static class AssertLogger
+    {
+        public static void IsNotNull(object value, string name = "")
+        {
+            bool passed = value != null;
+            TestOutputLogger.LogAssertion($"IsNotNull({name})", "NotNull", value?.ToString() ?? "null", passed);
+            Assert.IsNotNull(value);
+        }
+
+        public static void IsNull(object value, string name = "")
+        {
+            bool passed = value == null;
+            TestOutputLogger.LogAssertion($"IsNull({name})", "null", value?.ToString() ?? "null", passed);
+            Assert.IsNull(value);
+        }
+
+        public static void AreEqual<T>(T expected, T actual, string name = "")
+        {
+            bool passed = Equals(expected, actual);
+            TestOutputLogger.LogAssertion($"AreEqual({name})", expected?.ToString() ?? "null", actual?.ToString() ?? "null", passed);
+            Assert.AreEqual(expected, actual);
+        }
+
+        public static void AreEqual<T>(T expected, T actual, string message, string name)
+        {
+            bool passed = Equals(expected, actual);
+            TestOutputLogger.LogAssertion($"AreEqual({name})", expected?.ToString() ?? "null", actual?.ToString() ?? "null", passed);
+            Assert.AreEqual(expected, actual, message);
+        }
+
+        public static void IsTrue(bool condition, string name = "")
+        {
+            TestOutputLogger.LogAssertion($"IsTrue({name})", "True", condition.ToString(), condition);
+            Assert.IsTrue(condition);
+        }
+
+        public static void IsTrue(bool condition, string message, string name)
+        {
+            TestOutputLogger.LogAssertion($"IsTrue({name})", "True", condition.ToString(), condition);
+            Assert.IsTrue(condition, message);
+        }
+
+        public static void IsFalse(bool condition, string name = "")
+        {
+            TestOutputLogger.LogAssertion($"IsFalse({name})", "False", condition.ToString(), !condition);
+            Assert.IsFalse(condition);
+        }
+
+        public static void IsFalse(bool condition, string message, string name)
+        {
+            TestOutputLogger.LogAssertion($"IsFalse({name})", "False", condition.ToString(), !condition);
+            Assert.IsFalse(condition, message);
+        }
+
+        public static void IsInstanceOfType(object value, Type expectedType, string name = "")
+        {
+            bool passed = value != null && expectedType.IsInstanceOfType(value);
+            TestOutputLogger.LogAssertion(
+                $"IsInstanceOfType({name})",
+                expectedType?.Name ?? "null",
+                value?.GetType()?.Name ?? "null",
+                passed);
+            Assert.IsInstanceOfType(value, expectedType);
+        }
+
+        public static T ThrowsException<T>(Action action, string name = "") where T : Exception
+        {
+            try
+            {
+                action();
+                TestOutputLogger.LogAssertion($"ThrowsException<{typeof(T).Name}>({name})", typeof(T).Name, "NoException", false);
+                throw new AssertFailedException($"Expected exception {typeof(T).Name} was not thrown.");
+            }
+            catch (T ex)
+            {
+                TestOutputLogger.LogAssertion($"ThrowsException<{typeof(T).Name}>({name})", typeof(T).Name, typeof(T).Name, true);
+                return ex;
+            }
+            catch (AssertFailedException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                TestOutputLogger.LogAssertion($"ThrowsException<{typeof(T).Name}>({name})", typeof(T).Name, ex.GetType().Name, false);
+                throw new AssertFailedException(
+                    $"Expected exception {typeof(T).Name} but got {ex.GetType().Name}: {ex.Message}", ex);
+            }
+        }
+
+        public static void Fail(string message)
+        {
+            TestOutputLogger.LogAssertion("Fail", "N/A", message ?? "", false);
+            Assert.Fail(message);
+        }
+
+        public static void Fail(string message, params object[] parameters)
+        {
+            TestOutputLogger.LogAssertion("Fail", "N/A", message ?? "", false);
+            Assert.Fail(message, parameters);
+        }
+
+        public static void Inconclusive(string message)
+        {
+            TestOutputLogger.LogAssertion("Inconclusive", "N/A", message ?? "", false);
+            Assert.Inconclusive(message);
+        }
+
+        /// <summary>
+        /// Asserts a Contentstack API error with an HTTP status in the allowed set.
+        /// </summary>
+        public static ContentstackErrorException ThrowsContentstackError(Action action, string name, params HttpStatusCode[] acceptableStatuses)
+        {
+            var ex = ThrowsException<ContentstackErrorException>(action, name);
+            IsTrue(
+                acceptableStatuses.Contains(ex.StatusCode),
+                $"Expected one of [{string.Join(", ", acceptableStatuses)}] but was {ex.StatusCode}",
+                "statusCode");
+            return ex;
+        }
+
+        /// <summary>
+        /// Async variant: runs the task and expects <see cref="ContentstackErrorException"/> with an allowed status.
+        /// </summary>
+        public static async Task<ContentstackErrorException> ThrowsContentstackErrorAsync(Func<Task> action, string name, params HttpStatusCode[] acceptableStatuses)
+        {
+            try
+            {
+                await action();
+                TestOutputLogger.LogAssertion($"ThrowsContentstackErrorAsync({name})", "ContentstackErrorException", "NoException", false);
+                throw new AssertFailedException($"Expected exception ContentstackErrorException was not thrown.");
+            }
+            catch (ContentstackErrorException ex)
+            {
+                IsTrue(
+                    acceptableStatuses.Contains(ex.StatusCode),
+                    $"Expected one of [{string.Join(", ", acceptableStatuses)}] but was {ex.StatusCode}",
+                    "statusCode");
+                TestOutputLogger.LogAssertion($"ThrowsContentstackErrorAsync({name})", nameof(ContentstackErrorException), ex.StatusCode.ToString(), true);
+                return ex;
+            }
+            catch (AssertFailedException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                TestOutputLogger.LogAssertion($"ThrowsContentstackErrorAsync({name})", nameof(ContentstackErrorException), ex.GetType().Name, false);
+                throw new AssertFailedException(
+                    $"Expected exception ContentstackErrorException but got {ex.GetType().Name}: {ex.Message}", ex);
+            }
+        }
+    }
+}

Contentstack.Management.Core.Tests/Helpers/ContentTypeFixtureLoader.cs

@@ -0,0 +1,23 @@
+using Contentstack.Management.Core.Models;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Contentstack.Management.Core.Tests.Helpers
+{
+    /// <summary>
+    /// Loads embedded content-type JSON and assigns unique UIDs/titles for disposable integration tests.
+    /// </summary>
+    public static class ContentTypeFixtureLoader
+    {
+        public static ContentModelling LoadFromMock(JsonSerializer serializer, string embeddedFileName, string uidSuffix)
+        {
+            var text = Contentstack.GetResourceText(embeddedFileName);
+            var jo = JObject.Parse(text);
+            var baseUid = jo["uid"]?.Value<string>() ?? "ct";
+            jo["uid"] = $"{baseUid}_{uidSuffix}";
+            var title = jo["title"]?.Value<string>() ?? "CT";
+            jo["title"] = $"{title} {uidSuffix}";
+            return jo.ToObject<ContentModelling>(serializer);
+        }
+    }
+}