PR is not calculating patch based on inherit prop

[facusantillo]

This is the following scenario, and I'm not sure if this is correct or it's a bug.

I have a Main branch with tag 1.2.0

I create from that tag a release branch: release/1.2.0

I create a hotfix branch from the release branch: hotfix/1.2.0_fixes

At this point, I have 3 branches and 1 tag.

I commit to the hotfix branch and create a PR targeting the release branch. The version should be calculated as 1.2.1-prXXXXX.XX but the version is being calculated as 1.3.0-prXXXXX.XX

Main (1.2.0 Tag)
   |
   v
release/1.2.0
   |
   v
hotfix/1.2.0_fixes
   |
   v
PR: hotfix -> release

Here is my yaml:

mode: ManualDeployment
commit-message-incrementing: Enabled
strategies:
- Fallback
- MergeMessage
- TaggedCommit

branches:
  main:
    mode: ManualDeployment 
    label: 'rev'
    increment: Minor
    prevent-increment:
      of-merged-branch: true
      when-current-commit-tagged: true
    track-merge-target: true
    track-merge-message: true
    regex: ^main$|^master$
    source-branches: []
    is-source-branch-for: []
    tracks-release-branches: false
    is-release-branch: false
    is-main-branch: true
    pre-release-weight: 60000

  develop:
    mode: ManualDeployment
    label: 'rev'
    increment: Minor
    prevent-increment:
      when-current-commit-tagged: false
    track-merge-target: true
    track-merge-message: true
    regex: ^develop$
    source-branches: []
    is-source-branch-for: []
    tracks-release-branches: false
    is-release-branch: false
    is-main-branch: false
    pre-release-weight: 60000

  release:
    mode: ManualDeployment
    label: 'rev'
    increment: Patch
    prevent-increment:
      of-merged-branch: true
      when-current-commit-tagged: false
    track-merge-target: true
    regex: ^releas(e|es)?[/-]
    source-branches: []
    is-source-branch-for: []
    tracks-release-branches: false
    is-release-branch: true
    is-main-branch: false
    pre-release-weight: 30000

  feature:
    mode: ContinuousDelivery
    label: '{BranchName}'
    increment: Inherit
    prevent-increment:
      when-current-commit-tagged: false
    track-merge-target: true
    track-merge-message: true
    regex: ^features?[/-](?<BranchName>.+)
    source-branches:
    - feature
    - hotfix
    - develop
    - main
    - release
    is-source-branch-for: []
    tracks-release-branches: false
    is-release-branch: false
    is-main-branch: false
    pre-release-weight: 30000

  pull-request:
    mode: ContinuousDelivery
    label: 'pr'
    increment: Inherit
    prevent-increment:
      of-merged-branch: true
      when-current-commit-tagged: false
    label-number-pattern: '[/-](?<number>\d+)'
    track-merge-target: true
    track-merge-message: true
    regex: ^pull?
    source-branches:
    - develop
    - main
    - release
    - feature
    - hotfix
    is-source-branch-for: []
    tracks-release-branches: false
    is-release-branch: false
    is-main-branch: false
    pre-release-weight: 30000

  hotfix:
    mode: ContinuousDelivery
    label: '{BranchName}'
    increment: Patch
    prevent-increment:
      when-current-commit-tagged: false
    track-merge-target: true
    regex: ^hotfix(es)?[/-]
    source-branches:
    - main
    - develop
    - release
    is-source-branch-for: []
    tracks-release-branches: false
    is-release-branch: false
    is-main-branch: false
    pre-release-weight: 30000

ignore:
  sha: []

Thanks!

[HHobeck]

So you have multiple branches which can be used for inheriting. In your case it is:

• a hotfix branch with patch increment
• a release branch with patch increment and
• a main branch with minor increment

GitVersion calculates for all branches (it can inherit from) the version number and uses the highest number.

branches:
  pull-request:
    increment: Inherit
    source-branches:
    - develop
    - main
    - release
    - feature
    - hotfix
...

Hope that makes sense.

[koosvanw]

I just stumbled upon this discussion which seems very similar to the situation I've been looking into, though it's slightly different. I can open a separate discussion for it if that's more appropriate.

I'm looking into the upgrade to v6 for one of our repos. We are working according to GitFlow mostly, but there are no naming conventions on branching.

Our workflow could be explained briefly as follows:

1. New features are implemented in a branch from develop and merged back to develop via PR.
2. Once every x time an RC-x.x.x branch is created from develop in order to test and stabilize the application.
   a. We tag this commit with the version prefixed with dev-. This helped us a lot in terms of speed when calculating the version due to the size of our repository in v5.
3. Fixes on the RC branch are made in a similar manner as to develop.
4. RC-x.x.x gets merged to main which creates a new release
   a. This bumps the minor version number
   b. The commit gets tagged
5. In case of hotfixes on main: these are made in separate branches off main and merged back to main.

A reproduction of this workflow looks like this in Git (please ignore the commit texts...) :

Because there are no naming conventions in the branches, I don't know by name where a certain branch was created from. Thus I have a single feature branch configuration which has develop, main and rc as source branches.

Now I run into issues when calculating the version number of these feature branches. Ultimately, every feature branch can be traced back to the develop branch, and thus inherits that configuration which has the increment version set to Minor. However when I branched off main I'd expect that the version number would be calculated based on the latest tag on main.

I have setup a repo which I used to track down if/how I could fix this in the configuration file, but since always the highest version is taken I don't believe I can resolve this in the configuration. The repo can be found here.

It seems to me that the first parent branch should be used to determine the calculated version, instead of just using all possible sources and taking the highest version.

Please let me know if I should open a separate issue/discussion topic about this. I'd like to know whether our workflow is/should be supported by GitVersion or if we need to do something else to make this work.

[HHobeck]

It seems to me that the first parent branch should be used to determine the calculated version, instead of just using all possible sources and taking the highest version.

The problem is that you might be not know what the first branch is. Please provide a simplified integration test to reproduce your scenario like I did in the post #4227 (reply in thread).

[HHobeck]

This is the resulting structure in git:

If we skip the hotfix branch for a moment: How would you make the decision wheither you branched from main or from release?

@asbjornu I think we should introduce a new property with name e.g. PullRequestTargetBranch and PullRequestSourceBranch in the class GitVersionContext which will be populated in the normalization process for each build agent. We can use this information to decide what the first parent branch is. In the example above we are merging from hotfix to the release branch and want only to use the release branch (not the main branch) as parent. If this property is not set the algorithm uses both branches and takes the highest version.

Edit:
AzureDevops variables: https://learn.microsoft.com/de-de/azure/devops/pipelines/build/variables?view=azure-devops&tabs=yaml#system-variables-devops-services

[koosvanw]

The problem is that you might be not know what the first branch is. Please provide a simplified integration test to reproduce your scenario like I did in the post #4227 (reply in thread).

The integration test is maybe not that simple, but I created one which is most similar to the test repository I used before to reproduce similar results:

    [Test]
    public void __Just_A_Test__()
    {
        var mainBranchName = "main";
        var developBranchName = "develop";
        var rcBranchName = "RC-4.20.0";
        var fixOnMainBranchName = "MakeAFixOnMainBranch";
        var fixOnRcBranchName = "DoSomeFixOnRcBranch";
        var featureOnDevelop = "SomeFeatureOnDevelop";

        var configuration = GitFlowConfigurationBuilder.New
            .WithBranch("main", _ => _
                .WithIncrement(IncrementStrategy.Patch))
            .WithBranch("develop", _ => _
                .WithIncrement(IncrementStrategy.Minor)
                .WithPreventIncrementOfMergedBranch(true)
                .WithTracksReleaseBranches(false)
                .WithLabel("develop"))
            .WithBranch("rc", _ => _
                .WithRegularExpression("^RC-4.[2-9]\\d(.[\\d]+)*$")
                .WithIncrement(IncrementStrategy.None)
                .WithIsReleaseBranch(true)
                .WithLabel("RC"))
            .WithBranch("feature", _ => _
                .WithRegularExpression("(?<BranchName>.+)")
                .WithIncrement(IncrementStrategy.Inherit)
                .WithLabel("dev")
                .WithSourceBranches("develop", "main", "rc")
                .WithTracksReleaseBranches(false)
                .WithDeploymentMode(DeploymentMode.ContinuousDelivery))
            .WithBranch("release", _ => _
                .WithRegularExpression("^$"))
            .WithTagPrefix("(dev-)?")
            .WithAssemblyVersioningScheme(AssemblyVersioningScheme.MajorMinorPatch)
            .WithAssemblyFileVersioningFormat("MajorMinorPatch")
            .WithAssemblyInformationalFormat("{SemVer}")
            .Build();

        using var fixture = new EmptyRepositoryFixture(developBranchName);

        fixture.MakeACommit();
        fixture.MakeACommit();

        fixture.BranchTo(mainBranchName);

        fixture.BranchTo(featureOnDevelop);
        fixture.MakeACommit();
        fixture.MakeACommit();

        fixture.Checkout(developBranchName);
        fixture.MergeNoFF(featureOnDevelop);
        fixture.Remove(featureOnDevelop);

        fixture.Checkout(mainBranchName);
        fixture.ApplyTag("4.19.85");

        fixture.BranchTo(fixOnMainBranchName);
        fixture.MakeACommit();
        fixture.MakeACommit();
        fixture.Checkout(mainBranchName);
        fixture.MergeNoFF(fixOnMainBranchName);
        fixture.Remove(fixOnMainBranchName);

        fixture.ApplyTag("4.19.86");

        var version = fixture.GetVersion(configuration).FullSemVer;

        fixture.Checkout(developBranchName);
        fixture.MakeACommit();
        fixture.MakeACommit();

        fixture.BranchTo(featureOnDevelop);
        fixture.MakeACommit();
        fixture.MakeACommit();

        fixture.Checkout(developBranchName);
        fixture.MergeNoFF(featureOnDevelop);
        fixture.Remove(featureOnDevelop);

        version = fixture.GetVersion(configuration).FullSemVer;

        fixture.BranchTo(rcBranchName);
        fixture.ApplyTag("dev-4.20.0");
        fixture.MakeACommit();

        fixture.BranchTo(fixOnRcBranchName);
        fixture.MakeACommit();
        fixture.Checkout(rcBranchName);
        fixture.MergeNoFF(fixOnRcBranchName);
        fixture.Remove(fixOnRcBranchName);

        version = fixture.GetVersion(configuration).FullSemVer;

        fixture.Checkout("develop");
        fixture.BranchTo(featureOnDevelop);
        fixture.MakeACommit();
        fixture.MakeACommit();

        version = fixture.GetVersion(configuration).FullSemVer;

        fixture.Checkout(rcBranchName);
        fixture.BranchTo(fixOnRcBranchName);
        fixture.MakeACommit();
        fixture.MakeACommit();

        version = fixture.GetVersion(configuration).FullSemVer;

        fixture.Checkout(mainBranchName);
        fixture.BranchTo(fixOnMainBranchName);
        fixture.MakeACommit();

        version = fixture.GetVersion(configuration).FullSemVer;

        fixture.AssertFullSemver("4.19.86", configuration, targetBranch:mainBranchName);
        fixture.AssertFullSemver("4.19.87-dev.1", configuration, targetBranch: fixOnMainBranchName);
        fixture.AssertFullSemver("4.20.0-RC.3", configuration, targetBranch:rcBranchName);
        fixture.AssertFullSemver("4.20.0-dev.5", configuration, targetBranch: fixOnRcBranchName);
        fixture.AssertFullSemver("4.21.0-dev.2", configuration, targetBranch:featureOnDevelop);
        fixture.AssertFullSemver("4.21.0-develop.0", configuration, targetBranch:developBranchName);
    }

It turns out a bit different than with the testing repository I set up manually, however it does become clear that the inheriting of the branch configuration seems to be unexpected for the branch created from RC-4.20.0. Since it's configuration is set to IncrementStrategy.None I would expect version 4.20.0-dev.5, however it turns out as 4.20.1-dev.5 where the patch version was incremented.

I'll see if I can look a bit more into this myself as well in order to provide more information.

Thanks for your time on this!

[HHobeck]

Sorry, but this is not what I mean with providing a simple integration test. ;)