feat: Added branch support in entry variants

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [v1.1.0](https://github.com/contentstack/contentstack-management-dotnet/tree/v1.1.0)(2026-07-20)
+
+ - **New**
+ - **Branch override for Entry Variants**: `Entry.Variant(uid?, branchUid?)` accepts an optional `branchUid` so a single variant call (`Find`, `Create`, `Update`, `Fetch`, `Delete`) can target a branch other than the `Stack`'s configured one, by overriding the `branch` request header. Passing `null`/whitespace falls back to the Stack's own branch.
+ - **Publish/Unpublish for Entry Variants**: `EntryVariant.Publish`/`PublishAsync` and `EntryVariant.Unpublish`/`UnpublishAsync`, matching the same `PublishUnpublishDetails` contract as `Entry.Publish`/`Unpublish`, and respecting the same branch override.
+
 ## [v1.0.0](https://github.com/contentstack/contentstack-management-dotnet/tree/v1.0.0)(2026-07-13)
 
  - **Breaking Change**

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

@@ -3481,6 +3481,194 @@ await AssertLogger.ThrowsContentstackErrorAsync(async () =>
  }
 
  #endregion
+
+ #region L — Branch Override Tests
+
+ private const string BranchOverrideUid = "dotnet_variant_br";
+
+ private void TryDeleteBranch(string uid)
+ {
+ if (string.IsNullOrEmpty(uid)) return;
+ var force = new global::Contentstack.Management.Core.Queryable.ParameterCollection();
+ force.Add("force", true);
+ try { _stack.Branch(uid).Delete(force); } catch { }
+ }
+
+ [TestMethod]
+ [DoNotParallelize]
+ public void Test083_Should_Create_Branch_For_Variant_Override_Tests()
+ {
+ if (string.IsNullOrEmpty(_entryUid) || string.IsNullOrEmpty(_variantUid))
+ {
+ Assert.Inconclusive("Setup not completed. Ensure Test001 runs first.");
+ return;
+ }
+
+ TestOutputLogger.LogContext("TestScenario", "VariantBranchOverride_Setup");
+
+ TryDeleteBranch(BranchOverrideUid);
+
+ try
+ {
+ var model = new BranchModel { Uid = BranchOverrideUid, Source = "main" };
+ ContentstackResponse response = _stack.Branch().Create(model);
+ AssertLogger.IsNotNull(response.OpenJsonObjectResponse(), "response");
+ }
+ catch (ContentstackErrorException cex) when (
+ cex.StatusCode == HttpStatusCode.Conflict ||
+ cex.StatusCode == (HttpStatusCode)422)
+ {
+ // Branch already exists from a previous run — that is fine for our purposes.
+ Console.WriteLine($"Branch '{BranchOverrideUid}' already exists (HTTP {(int)cex.StatusCode}); continuing.");
+ }
+ catch (Exception ex)
+ {
+ Assert.Inconclusive("Could not create a branch for branch-override tests (branching may not be enabled on this stack): " + ex.Message);
+ }
+ }
+
+ [TestMethod]
+ [DoNotParallelize]
+ public void Test084_Should_Fetch_Variant_On_Explicit_Branch()
+ {
+ if (string.IsNullOrEmpty(_entryUid) || string.IsNullOrEmpty(_variantUid))
+ {
+ Assert.Inconclusive("Setup not completed. Ensure Test001 runs first.");
+ return;
+ }
+
+ TestOutputLogger.LogContext("TestScenario", "VariantBranchOverride_Fetch");
+
+ try
+ {
+ // The variant/entry may not have been synced onto the new branch yet, so we only
+ // assert that the SDK successfully issues the request with the branch override —
+ // not that the API necessarily has matching content on that branch.
+ var response = _stack.ContentType(_contentTypeUid).Entry(_entryUid).Variant(_variantUid, BranchOverrideUid).Fetch();
+ Console.WriteLine("Fetch on explicit branch response: " + response.OpenResponse());
+ AssertLogger.IsTrue(
+ response.IsSuccessStatusCode,
+ "Expected a 2xx response when fetching a variant with a valid branch override (errors would have thrown ContentstackErrorException)",
+ "FetchVariantOnExplicitBranch");
+ }
+ catch (ContentstackErrorException cex)
+ {
+ Console.WriteLine("Fetch on explicit branch failed (acceptable if content hasn't synced to the branch yet): " + cex.Message);
+ }
+ }
+
+ [TestMethod]
+ [DoNotParallelize]
+ public async Task Test085_Should_Fetch_Variant_On_Explicit_Branch_Async()
+ {
+ if (string.IsNullOrEmpty(_entryUid) || string.IsNullOrEmpty(_variantUid))
+ {
+ Assert.Inconclusive("Setup not completed. Ensure Test001 runs first.");
+ return;
+ }
+
+ TestOutputLogger.LogContext("TestScenario", "VariantBranchOverride_FetchAsync");
+
+ try
+ {
+ var response = await _stack.ContentType(_contentTypeUid).Entry(_entryUid).Variant(_variantUid, BranchOverrideUid).FetchAsync();
+ Console.WriteLine("FetchAsync on explicit branch response: " + response.OpenResponse());
+ AssertLogger.IsTrue(
+ response.IsSuccessStatusCode,
+ "Expected a 2xx response when fetching a variant with a valid branch override (errors would have thrown ContentstackErrorException)",
+ "FetchVariantOnExplicitBranchAsync");
+ }
+ catch (ContentstackErrorException cex)
+ {
+ Console.WriteLine("FetchAsync on explicit branch failed (acceptable if content hasn't synced to the branch yet): " + cex.Message);
+ }
+ }
+
+ [TestMethod]
+ [DoNotParallelize]
+ public async Task Test086_Should_Fail_To_Fetch_Variant_On_Invalid_Branch()
+ {
+ if (string.IsNullOrEmpty(_entryUid) || string.IsNullOrEmpty(_variantUid))
+ {
+ Assert.Inconclusive("Setup not completed. Ensure Test001 runs first.");
+ return;
+ }
+
+ TestOutputLogger.LogContext("TestScenario", "VariantBranchOverride_InvalidBranch");
+
+ await AssertLogger.ThrowsContentstackErrorAsync(async () =>
+ {
+ var response = await _stack.ContentType(_contentTypeUid).Entry(_entryUid).Variant(_variantUid, "definitely_invalid_branch").FetchAsync();
+ if (!response.IsSuccessStatusCode)
+ {
+ throw new ContentstackErrorException
+ {
+ StatusCode = response.StatusCode,
+ ErrorMessage = "Invalid branch UID"
+ };
+ }
+ }, "FetchVariantOnInvalidBranch", HttpStatusCode.NotFound, (HttpStatusCode)422, HttpStatusCode.BadRequest, HttpStatusCode.Unauthorized, HttpStatusCode.Forbidden);
+ }
+
+ [TestMethod]
+ [DoNotParallelize]
+ public async Task Test087_Should_Fallback_To_Stack_Branch_When_BranchUid_Is_Blank()
+ {
+ if (string.IsNullOrEmpty(_entryUid) || string.IsNullOrEmpty(_variantUid))
+ {
+ Assert.Inconclusive("Setup not completed. Ensure Test001 runs first.");
+ return;
+ }
+
+ TestOutputLogger.LogContext("TestScenario", "VariantBranchOverride_BlankFallback");
+
+ // A blank/whitespace branchUid must behave identically to omitting it entirely —
+ // i.e. fall back to the Stack's configured branch (main, in these tests).
+ var withoutOverride = await _stack.ContentType(_contentTypeUid).Entry(_entryUid).Variant().FindAsync();
+ var withBlankOverride = await _stack.ContentType(_contentTypeUid).Entry(_entryUid).Variant(branchUid: " ").FindAsync();
+
+ Assert.AreEqual(withoutOverride.IsSuccessStatusCode, withBlankOverride.IsSuccessStatusCode,
+ "A blank branchUid should fall back to the Stack's branch, matching the no-override request");
+ }
+
+ [TestMethod]
+ [DoNotParallelize]
+ public async Task Test088_Should_Publish_Variant_With_Explicit_Branch_Override()
+ {
+ if (string.IsNullOrEmpty(_entryUid) || string.IsNullOrEmpty(_variantUid))
+ {
+ Assert.Inconclusive("Setup not completed. Ensure Test001 runs first.");
+ return;
+ }
+
+ TestOutputLogger.LogContext("TestScenario", "VariantBranchOverride_Publish");
+
+ var publishDetails = new PublishUnpublishDetails
+ {
+ Locales = new List<string> { "en-us" },
+ Environments = new List<string> { "development" }
+ };
+
+ try
+ {
+ var response = await _stack.ContentType(_contentTypeUid).Entry(_entryUid).Variant(_variantUid, BranchOverrideUid).PublishAsync(publishDetails, "en-us");
+ Console.WriteLine("Publish with branch override response: " + response.OpenResponse());
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine("Publish with branch override failed (often due to missing 'development' environment on the branch). Continuing. Exception: " + ex.Message);
+ }
+ }
+
+ [TestMethod]
+ [DoNotParallelize]
+ public void Test089_Should_Cleanup_Branch_For_Variant_Override_Tests()
+ {
+ TestOutputLogger.LogContext("TestScenario", "VariantBranchOverride_Cleanup");
+ TryDeleteBranch(BranchOverrideUid);
+ }
+
+ #endregion
  }
 
  /// <summary>

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

@@ -13,13 +13,15 @@ public class EntryVariantTest
  private Stack _stack;
  private readonly IFixture _fixture = new Fixture();
  private ContentstackResponse _contentstackResponse;
+ private MockHttpHandler _mockHttpHandler;
 
  [TestInitialize]
  public void initialize()
  {
  var client = new ContentstackClient();
  _contentstackResponse = MockResponse.CreateContentstackResponse("MockResponse.txt");
- client.ContentstackPipeline.ReplaceHandler(new MockHttpHandler(_contentstackResponse));
+ _mockHttpHandler = new MockHttpHandler(_contentstackResponse);
+ client.ContentstackPipeline.ReplaceHandler(_mockHttpHandler);
  client.contentstackOptions.Authtoken = _fixture.Create<string>();
  _stack = new Stack(client, _fixture.Create<string>());
  }
@@ -147,5 +149,166 @@ public void Should_Delete_EntryVariant()
 
  Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
  }
+
+ [TestMethod]
+ public void Initialize_EntryVariant_With_BranchUid()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var branchUid = _fixture.Create<string>();
+
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, branchUid: branchUid);
+
+ Assert.AreEqual(branchUid, variant.branchUid);
+ }
+
+ [TestMethod]
+ public void Should_Override_Branch_Header_On_Find_When_BranchUid_Provided()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var branchUid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, branchUid: branchUid);
+
+ variant.Find();
+
+ Assert.AreEqual(branchUid, _mockHttpHandler.LastRequestHeaders["branch"]);
+ }
+
+ [TestMethod]
+ public void Should_Override_Branch_Header_On_Create_When_BranchUid_Provided()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var uid = _fixture.Create<string>();
+ var branchUid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, uid, branchUid);
+ var model = new { entry = new { banner_color = "Navy Blue" } };
+
+ variant.Create(model);
+
+ Assert.AreEqual(branchUid, _mockHttpHandler.LastRequestHeaders["branch"]);
+ }
+
+ [TestMethod]
+ public void Should_Override_Branch_Header_On_Fetch_When_BranchUid_Provided()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var uid = _fixture.Create<string>();
+ var branchUid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, uid, branchUid);
+
+ variant.Fetch();
+
+ Assert.AreEqual(branchUid, _mockHttpHandler.LastRequestHeaders["branch"]);
+ }
+
+ [TestMethod]
+ public void Should_Override_Branch_Header_On_Delete_When_BranchUid_Provided()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var uid = _fixture.Create<string>();
+ var branchUid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, uid, branchUid);
+
+ variant.Delete();
+
+ Assert.AreEqual(branchUid, _mockHttpHandler.LastRequestHeaders["branch"]);
+ }
+
+ [TestMethod]
+ public void Should_Fallback_To_Stack_Branch_When_BranchUid_Is_Empty()
+ {
+ var stackBranchUid = _fixture.Create<string>();
+ var client = new ContentstackClient();
+ var mockHttpHandler = new MockHttpHandler(_contentstackResponse);
+ client.ContentstackPipeline.ReplaceHandler(mockHttpHandler);
+ client.contentstackOptions.Authtoken = _fixture.Create<string>();
+ var stack = new Stack(client, _fixture.Create<string>(), branchUid: stackBranchUid);
+
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(stack, ctUid, entryUid, branchUid: " ");
+
+ variant.Find();
+
+ Assert.AreEqual(stackBranchUid, mockHttpHandler.LastRequestHeaders["branch"]);
+ }
+
+ [TestMethod]
+ public void Should_Publish_EntryVariant()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var uid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, uid);
+ var details = new PublishUnpublishDetails { Locales = new System.Collections.Generic.List<string> { "en-us" }, Version = 1 };
+
+ ContentstackResponse response = variant.Publish(details);
+
+ Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+ Assert.IsTrue(details.Variants.Exists(v => v.Uid == uid));
+ }
+
+ [TestMethod]
+ public async System.Threading.Tasks.Task Should_Publish_EntryVariant_Async()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var uid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, uid);
+ var details = new PublishUnpublishDetails();
+
+ ContentstackResponse response = await variant.PublishAsync(details);
+
+ Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+ Assert.IsTrue(details.Variants.Exists(v => v.Uid == uid));
+ }
+
+ [TestMethod]
+ public void Should_Unpublish_EntryVariant()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var uid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, uid);
+ var details = new PublishUnpublishDetails();
+
+ ContentstackResponse response = variant.Unpublish(details);
+
+ Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+ Assert.IsTrue(details.Variants.Exists(v => v.Uid == uid));
+ }
+
+ [TestMethod]
+ public async System.Threading.Tasks.Task Should_Unpublish_EntryVariant_Async()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var uid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, uid);
+ var details = new PublishUnpublishDetails();
+
+ ContentstackResponse response = await variant.UnpublishAsync(details);
+
+ Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+ Assert.IsTrue(details.Variants.Exists(v => v.Uid == uid));
+ }
+
+ [TestMethod]
+ public void Should_Override_Branch_Header_On_Publish_When_BranchUid_Provided()
+ {
+ var ctUid = _fixture.Create<string>();
+ var entryUid = _fixture.Create<string>();
+ var uid = _fixture.Create<string>();
+ var branchUid = _fixture.Create<string>();
+ EntryVariant variant = new EntryVariant(_stack, ctUid, entryUid, uid, branchUid);
+
+ variant.Publish(new PublishUnpublishDetails());
+
+ Assert.AreEqual(branchUid, _mockHttpHandler.LastRequestHeaders["branch"]);
+ }
  }
 }