Config based versioning

GitVersionCore.Tests/GitVersionContextBuilder.cs

@@ -0,0 +1,76 @@
+namespace GitVersionCore.Tests
+{
+    using GitVersion;
+    using LibGit2Sharp;
+
+    public class GitVersionContextBuilder
+    {
+        IRepository repository;
+        Config config;
+
+        public GitVersionContextBuilder WithRepository(IRepository repository)
+        {
+            this.repository = repository;
+            return this;
+        }
+
+        public GitVersionContextBuilder WithConfig(Config config)
+        {
+            this.config = config;
+            return this;
+        }
+
+        public GitVersionContextBuilder WithTaggedMaster()
+        {
+            repository = CreateRepository();
+            var target = repository.Head.Tip;
+            ((MockTagCollection)repository.Tags).Add(new MockTag ("1.0.0", target));
+            ((MockBranch)repository.Head).Add(new MockCommit { CommitterEx = SignatureBuilder.SignatureNow() });
+            return this;
+        }
+
+        public GitVersionContextBuilder AddCommit()
+        {
+            ((MockBranch)repository.Head).Add(new MockCommit());
+            return this;
+        }
+
+        public GitVersionContextBuilder WithDevelopBranch()
+        {
+            return WithBranch("develop");
+        }
+
+        public GitVersionContextBuilder WithBranch(string branchName)
+        {
+            repository = CreateRepository();
+            var mockBranch = new MockBranch(branchName)
+            {
+                new MockCommit()
+            };
+            ((MockBranchCollection)repository.Branches).Add(mockBranch);
+            ((MockRepository)repository).Head = mockBranch;
+            return this;
+        }
+
+        public GitVersionContext Build()
+        {
+            return new GitVersionContext(repository ?? CreateRepository(), config ?? new Config());
+        }
+
+        IRepository CreateRepository()
+        {
+            var mockBranch = new MockBranch("master") { new MockCommit { CommitterEx = SignatureBuilder.SignatureNow() } };
+            var mockRepository = new MockRepository
+            {
+                Branches = new MockBranchCollection
+                {
+                    mockBranch
+                },
+                Tags = new MockTagCollection(),
+                Head = mockBranch
+            };
+
+            return mockRepository;
+        }
+    }
+}

GitVersionCore.Tests/GitVersionCore.Tests.csproj

@@ -115,6 +115,15 @@
     <Compile Include="TestEffectiveConfiguration.cs" />
     <Compile Include="TestFileSystem.cs" />
     <Compile Include="VariableProviderTests.cs" />
+    <Compile Include="VersionCalculation\BaseVersionCalculatorTests.cs" />
+    <Compile Include="VersionCalculation\NewNextVersionCalculatorTests.cs" />
+    <Compile Include="VersionCalculation\Strategies\ConfigNextVersionBaseVersionStrategyTests.cs" />
+    <Compile Include="GitVersionContextBuilder.cs" />
+    <Compile Include="VersionCalculation\Strategies\LastTagBaseVersionStrategyTests.cs" />
+    <Compile Include="VersionCalculation\Strategies\MergeMessageBaseVersionStrategyTests.cs" />
+    <Compile Include="VersionCalculation\Strategies\VersionInBranchBaseVersionStrategyTests.cs" />
+    <Compile Include="VersionCalculation\TestBaseVersionCalculator.cs" />
+    <Compile Include="VersionCalculation\TestMetaDataCalculator.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

GitVersionCore.Tests/Mocks/MockTag.cs

@@ -15,6 +15,15 @@ public override GitObject Target
         get { return TargetEx; }
     }
     public TagAnnotation AnnotationEx;
+
+    public MockTag() { }
+
+    public MockTag(string name, Commit target)
+    {
+        NameEx = name;
+        TargetEx = target;
+    }
+
     public override TagAnnotation Annotation
     {
         get { return AnnotationEx; }

GitVersionCore.Tests/TestEffectiveConfiguration.cs

@@ -10,7 +10,7 @@ public TestEffectiveConfiguration(
             string gitTagPrefix = "v", 
             string tag = "",
             string nextVersion = null) : 
-                base(assemblyVersioningScheme, versioningMode, gitTagPrefix, tag, nextVersion)
+                base(assemblyVersioningScheme, versioningMode, gitTagPrefix, tag, nextVersion, IncrementStrategy.Patch)
         {
         }
     }

GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs

@@ -0,0 +1,86 @@
+namespace GitVersionCore.Tests.VersionCalculation
+{
+    using System;
+    using GitVersion;
+    using GitVersion.VersionCalculation;
+    using GitVersion.VersionCalculation.BaseVersionCalculators;
+    using LibGit2Sharp;
+    using NUnit.Framework;
+    using Shouldly;
+
+    [TestFixture]
+    public class BaseVersionCalculatorTests
+    {
+        [Test]
+        public void ChoosesHighestVersionReturnedFromStrategies()
+        {
+            var context = new GitVersionContextBuilder().Build();
+            var dateTimeOffset = DateTimeOffset.Now;
+            var sut = new BaseVersionCalculator(new V1Strategy(DateTimeOffset.Now), new V2Strategy(dateTimeOffset));
+
+            var baseVersion = sut.GetBaseVersion(context);
+
+            baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
+            baseVersion.ShouldIncrement.ShouldBe(true);
+            baseVersion.BaseVersionSource.When().ShouldBe(dateTimeOffset);
+        }
+
+        [Test]
+        public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhen()
+        {
+            var context = new GitVersionContextBuilder().Build();
+            var when = DateTimeOffset.Now;
+            var sut = new BaseVersionCalculator(new V1Strategy(when), new V2Strategy(null));
+
+            var baseVersion = sut.GetBaseVersion(context);
+
+            baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
+            baseVersion.ShouldIncrement.ShouldBe(true);
+            baseVersion.BaseVersionSource.When().ShouldBe(when);
+        }
+
+        [Test]
+        public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhenReversedOrder()
+        {
+            var context = new GitVersionContextBuilder().Build();
+            var when = DateTimeOffset.Now;
+            var sut = new BaseVersionCalculator(new V1Strategy(null), new V2Strategy(when));
+
+            var baseVersion = sut.GetBaseVersion(context);
+
+            baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
+            baseVersion.ShouldIncrement.ShouldBe(true);
+            baseVersion.BaseVersionSource.When().ShouldBe(when);
+        }
+
+        class V1Strategy : BaseVersionStrategy
+        {
+            readonly Commit when;
+
+            public V1Strategy(DateTimeOffset? when)
+            {
+                this.when = when == null ? null : new MockCommit { CommitterEx = when.Value.ToSignature() };
+            }
+
+            public override BaseVersion GetVersion(GitVersionContext context)
+            {
+                return new BaseVersion(false, new SemanticVersion(1), when);
+            }
+        }
+
+        class V2Strategy : BaseVersionStrategy
+        {
+            Commit when;
+
+            public V2Strategy(DateTimeOffset? when)
+            {
+                this.when = when == null ? null : new MockCommit { CommitterEx = when.Value.ToSignature() };
+            }
+
+            public override BaseVersion GetVersion(GitVersionContext context)
+            {
+                return new BaseVersion(true, new SemanticVersion(2), when);
+            }
+        }
+    }
+}

GitVersionCore.Tests/VersionCalculation/NewNextVersionCalculatorTests.cs

@@ -0,0 +1,62 @@
+namespace GitVersionCore.Tests.VersionCalculation
+{
+    using System;
+    using GitVersion;
+    using GitVersion.VersionCalculation;
+    using NUnit.Framework;
+    using Shouldly;
+
+    public class NewNextVersionCalculatorTests
+    {
+        [Test]
+        public void ShouldIncrementVersionBasedOnConfig()
+        {
+            var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1), new MockCommit());
+            var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);
+            var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
+            var config = new Config();
+            config.Branches.Add("master", new BranchConfig
+            {
+                Increment = IncrementStrategy.Major
+            });
+            var context = new GitVersionContextBuilder().WithConfig(config).Build();
+
+            var version = sut.FindVersion(context);
+
+            version.ToString().ShouldBe("2.0.0");
+        }
+
+        [Test]
+        public void DoesNotIncrementWhenBaseVersionSaysNotTo()
+        {
+            var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
+            var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);
+            var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
+            var config = new Config();
+            config.Branches.Add("master", new BranchConfig
+            {
+                Increment = IncrementStrategy.Major
+            });
+            var context = new GitVersionContextBuilder().WithConfig(config).Build();
+
+            var version = sut.FindVersion(context);
+
+            version.ToString().ShouldBe("1.0.0");
+        }
+
+        [Test]
+        public void AppliesBranchPreReleaseTag()
+        {
+            var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
+            var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "develop", "b1a34e", DateTimeOffset.Now);
+            var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
+            var context = new GitVersionContextBuilder()
+                .WithDevelopBranch()
+                .Build();
+
+            var version = sut.FindVersion(context);
+
+            version.ToString().ShouldBe("1.0.0-unstable.1");
+        }
+    }
+}

GitVersionCore.Tests/VersionCalculation/Strategies/ConfigNextVersionBaseVersionStrategyTests.cs

@@ -0,0 +1,38 @@
+namespace GitVersionCore.Tests.VersionCalculation.Strategies
+{
+    using GitVersion;
+    using GitVersion.VersionCalculation.BaseVersionCalculators;
+    using NUnit.Framework;
+    using Shouldly;
+
+    [TestFixture]
+    public class ConfigNextVersionBaseVersionStrategyTests
+    {
+        [Test]
+        public void ShouldNotBeIncremented()
+        {
+            var contextBuilder = new GitVersionContextBuilder()
+                .WithConfig(new Config
+                {
+                    NextVersion = "1.0.0"
+                });
+            var sut = new ConfigNextVersionBaseVersionStrategy();
+
+            var baseVersion = sut.GetVersion(contextBuilder.Build());
+
+            baseVersion.ShouldIncrement.ShouldBe(false);
+            baseVersion.SemanticVersion.ToString().ShouldBe("1.0.0");
+        }
+
+        [Test]
+        public void ReturnsNullWhenNoNextVersionIsInConfig()
+        {
+            var contextBuilder = new GitVersionContextBuilder();
+            var sut = new ConfigNextVersionBaseVersionStrategy();
+
+            var baseVersion = sut.GetVersion(contextBuilder.Build());
+
+            baseVersion.ShouldBe(null);
+        }
+    }
+}

GitVersionCore.Tests/VersionCalculation/Strategies/LastTagBaseVersionStrategyTests.cs

@@ -0,0 +1,37 @@
+namespace GitVersionCore.Tests.VersionCalculation.Strategies
+{
+    using GitVersion.VersionCalculation.BaseVersionCalculators;
+    using NUnit.Framework;
+    using Shouldly;
+
+    [TestFixture]
+    public class LastTagBaseVersionStrategyTests
+    {
+        [Test]
+        public void ShouldAllowVersionIncrement()
+        {
+            var context = new GitVersionContextBuilder()
+                .WithTaggedMaster()
+                .AddCommit()
+                .Build();
+            var sut = new LastTagBaseVersionStrategy();
+
+            var baseVersion = sut.GetVersion(context);
+
+            baseVersion.ShouldIncrement.ShouldBe(true);
+        }
+
+        [Test]
+        public void ShouldNotAllowVersionIncrementWhenTagComesFromCurrentCommit()
+        {
+            var context = new GitVersionContextBuilder()
+                .WithTaggedMaster()
+                .Build();
+            var sut = new LastTagBaseVersionStrategy();
+
+            var baseVersion = sut.GetVersion(context);
+
+            baseVersion.ShouldIncrement.ShouldBe(false);
+        }
+    }
+}