Пример #1
0
    public void VerifyCreatedCode([ValueSource("compilers")] ICompiler compiler)
    {
        var semanticVersion = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            PreReleaseTag = "unstable4",
            BuildMetaData = new SemanticVersionBuildMetaData(5,
                                                             "feature1", "commitSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z"))
        };

        var config = new TestEffectiveConfiguration();

        var versionVariables = VariableProvider.GetVariablesFor(semanticVersion, config, false);
        var assemblyInfoText = compiler.Builder.GetAssemblyInfoText(versionVariables, "Fake");

        assemblyInfoText.ShouldMatchApproved(c => c.SubFolder(compiler.ApprovedSubFolder));

        var compilation = compiler.Compile(assemblyInfoText);

        using (var stream = new MemoryStream())
        {
            var emitResult = compilation.Emit(stream);

            Assert.IsTrue(emitResult.Success, string.Join(Environment.NewLine, emitResult.Diagnostics.Select(x => x.Descriptor)));

            stream.Seek(0, SeekOrigin.Begin);
            var assembly = Assembly.Load(stream.ToArray());
            VerifyGitVersionInformationAttribute(assembly, versionVariables);
        }
    }
Пример #2
0
    private void AssertVariablesAreWrittenToFile(string file)
    {
        var writes          = new List <string?>();
        var semanticVersion = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            PreReleaseTag = "beta1",
            BuildMetaData = "5"
        };

        semanticVersion.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");
        semanticVersion.BuildMetaData.Sha        = "commitSha";

        var config = new TestEffectiveConfiguration();

        var variableProvider = this.sp.GetRequiredService <IVariableProvider>();

        var variables = variableProvider.GetVariablesFor(semanticVersion, config, false);

        this.buildServer.WithPropertyFile(file);

        this.buildServer.WriteIntegration(writes.Add, variables);

        writes[1].ShouldBe("1.2.3-beta.1+5");

        File.Exists(file).ShouldBe(true);

        var props = File.ReadAllText(file);

        props.ShouldContain("GitVersion_Major=1");
        props.ShouldContain("GitVersion_Minor=2");
    }
Пример #3
0
    public void BuildNumberIsFullSemVer()
    {
        var writes          = new List <string?>();
        var semanticVersion = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            PreReleaseTag = "beta1",
            BuildMetaData = "5"
        };

        semanticVersion.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");
        semanticVersion.BuildMetaData.Sha        = "commitSha";

        var config = new TestEffectiveConfiguration();

        var variables  = this.buildServer.GetVariablesFor(semanticVersion, config, false);
        var buildAgent = this.sp.GetRequiredService <BuildAgent>();

        buildAgent.WriteIntegration(writes.Add, variables);

        writes[1].ShouldBe("1.2.3-beta.1+5");

        writes = new List <string?>();
        buildAgent.WriteIntegration(writes.Add, variables, false);
        writes.ShouldNotContain(x => x != null && x.StartsWith("Executing GenerateSetVersionMessage for "));
    }
Пример #4
0
    public void ShouldReplaceAssemblyVersionWithStar()
    {
        var fileSystem = Substitute.For <IFileSystem>();
        var version    = new SemanticVersion
        {
            BuildMetaData = new SemanticVersionBuildMetaData(3, "foo", "hash", DateTimeOffset.Now),
            Major         = 2,
            Minor         = 3,
            Patch         = 1
        };

        const string workingDir       = "C:\\Testing";
        const string assemblyInfoFile = @"AssemblyVersion(""1.0.0.*"");
AssemblyInformationalVersion(""1.0.0.*"");
AssemblyFileVersion(""1.0.0.*"");";

        fileSystem.Exists("C:\\Testing\\AssemblyInfo.cs").Returns(true);
        fileSystem.ReadAllText("C:\\Testing\\AssemblyInfo.cs").Returns(assemblyInfoFile);

        var config   = new TestEffectiveConfiguration(assemblyVersioningScheme: AssemblyVersioningScheme.MajorMinor);
        var variable = VariableProvider.GetVariablesFor(version, config, false);
        var args     = new Arguments
        {
            UpdateAssemblyInfo         = true,
            UpdateAssemblyInfoFileName = "AssemblyInfo.cs"
        };

        using (new AssemblyInfoFileUpdate(args, workingDir, variable, fileSystem))
        {
            const string expected = @"AssemblyVersion(""2.3.0.0"");
AssemblyInformationalVersion(""2.3.1+3.Branch.foo.Sha.hash"");
AssemblyFileVersion(""2.3.1.0"");";
            fileSystem.Received().WriteAllText("C:\\Testing\\AssemblyInfo.cs", expected);
        }
    }
Пример #5
0
        private void AssertVariablesAreWrittenToFile(string f)
        {
            var writes          = new List <string>();
            var semanticVersion = new SemanticVersion
            {
                Major         = 1,
                Minor         = 2,
                Patch         = 3,
                PreReleaseTag = "beta1",
                BuildMetaData = "5"
            };

            semanticVersion.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");
            semanticVersion.BuildMetaData.Sha        = "commitSha";

            var config = new TestEffectiveConfiguration();

            var variables = VariableProvider.GetVariablesFor(semanticVersion, config, false);

            var j = new GitLabCi(environment, f);

            j.WriteIntegration(writes.Add, variables);

            writes[1].ShouldBe("1.2.3-beta.1+5");

            File.Exists(f).ShouldBe(true);

            var props = File.ReadAllText(f);

            props.ShouldContain("GitVersion_Major=1");
            props.ShouldContain("GitVersion_Minor=2");
        }
    private void AssertVariablesAreWrittenToFile(string file)
    {
        var writes          = new List <string?>();
        var semanticVersion = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            PreReleaseTag = "beta1",
            BuildMetaData = "5"
        };

        semanticVersion.BuildMetaData.CommitDate = new DateTimeOffset(2022, 4, 6, 16, 10, 59, TimeSpan.FromHours(10));
        semanticVersion.BuildMetaData.Sha        = "f28807e615e9f06aec8a33c87780374e0c1f6fb8";

        var config           = new TestEffectiveConfiguration();
        var variableProvider = this.sp.GetRequiredService <IVariableProvider>();

        var variables = variableProvider.GetVariablesFor(semanticVersion, config, false);

        this.buildServer.WithPropertyFile(file);

        this.buildServer.WriteIntegration(writes.Add, variables);

        writes[1].ShouldBe("1.2.3-beta.1+5");

        File.Exists(file).ShouldBe(true);

        var props = File.ReadAllText(file);

        props.ShouldContain("export GITVERSION_MAJOR=1");
        props.ShouldContain("export GITVERSION_MINOR=2");
        props.ShouldContain("export GITVERSION_SHA=f28807e615e9f06aec8a33c87780374e0c1f6fb8");
        props.ShouldContain("export GITVERSION_COMMITDATE=2022-04-06");
    }
    private void VerifyAssemblyInfoFile(
        string assemblyFileContent,
        string fileName,
        AssemblyVersioningScheme versioningScheme     = AssemblyVersioningScheme.MajorMinorPatch,
        Action <IFileSystem, VersionVariables>?verify = null)
    {
        this.fileSystem = Substitute.For <IFileSystem>();
        var version = new SemanticVersion
        {
            BuildMetaData = new SemanticVersionBuildMetaData("versionSourceHash", 3, "foo", "hash", "shortHash", DateTimeOffset.Now, 0),
            Major         = 2,
            Minor         = 3,
            Patch         = 1
        };

        this.fileSystem.Exists(fileName).Returns(true);
        this.fileSystem.ReadAllText(fileName).Returns(assemblyFileContent);
        this.fileSystem.When(f => f.WriteAllText(fileName, Arg.Any <string>())).Do(c =>
        {
            assemblyFileContent = c.ArgAt <string>(1);
            this.fileSystem.ReadAllText(fileName).Returns(assemblyFileContent);
        });

        var config    = new TestEffectiveConfiguration(versioningScheme);
        var variables = this.variableProvider.GetVariablesFor(version, config, false);

        verify?.Invoke(this.fileSystem, variables);
    }
Пример #8
0
    static void VerifyAssemblyVersion(AssemblyVersioningScheme avs, string assemblyInformationalFormat = null)
    {
        var semanticVersion = new SemanticVersion
        {
            Major         = 2,
            Minor         = 3,
            Patch         = 4,
            PreReleaseTag = "beta.5",
            BuildMetaData = new SemanticVersionBuildMetaData(6,
                                                             "master", "commitSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z")),
        };
        var assemblyInfoBuilder = new AssemblyInfoBuilder();


        var config = new TestEffectiveConfiguration(assemblyVersioningScheme: avs, assemblyInformationalFormat: assemblyInformationalFormat);

        var versionVariables = VariableProvider.GetVariablesFor(semanticVersion, config, false);
        var assemblyInfoText = assemblyInfoBuilder.GetAssemblyInfoText(versionVariables, "Fake");

        Approvals.Verify(assemblyInfoText);

        var compilation = CSharpCompilation.Create("Fake.dll")
                          .WithOptions(new CSharpCompilationOptions(OutputKind.NetModule))
                          .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
                          .AddSyntaxTrees(CSharpSyntaxTree.ParseText(assemblyInfoText));

        var emitResult = compilation.Emit(new MemoryStream());

        Assert.IsTrue(emitResult.Success, string.Join(Environment.NewLine, emitResult.Diagnostics.Select(x => x.Descriptor)));
    }
Пример #9
0
    public void VerifyCreatedCode_NoNamespaceConflict()
    {
        var semanticVersion = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            PreReleaseTag = "unstable4",
            BuildMetaData = new SemanticVersionBuildMetaData(5,
                                                             "feature1", "commitSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z"))
        };
        var assemblyInfoBuilder = new AssemblyInfoBuilder();

        var config = new TestEffectiveConfiguration();

        var versionVariables = VariableProvider.GetVariablesFor(semanticVersion, config, false);
        var assemblyInfoText = assemblyInfoBuilder.GetAssemblyInfoText(versionVariables, "Fake.System");

        Approvals.Verify(assemblyInfoText);

        var compilation = CSharpCompilation.Create("Fake.System.dll")
                          .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
                          .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
                          .AddSyntaxTrees(CSharpSyntaxTree.ParseText(assemblyInfoText));

        var emitResult = compilation.Emit(new MemoryStream());

        Assert.IsTrue(emitResult.Success, string.Join(Environment.NewLine, emitResult.Diagnostics.Select(x => x.Descriptor)));
    }
Пример #10
0
        private static void VerifyAssemblyInfoFile(
            string assemblyFileContent,
            string fileName,
            AssemblyVersioningScheme versioningScheme            = AssemblyVersioningScheme.MajorMinorPatch,
            Action <Mock <IFileSystem>, VersionVariables> verify = null)
        {
            var version = new SemanticVersion
                          (
                major: 2,
                minor: 3,
                patch: 1,
                buildMetadata: new BuildMetadata(3, "foo", "hash", DateTimeOffset.Now)
                          );

            var fileSystem = new Mock <IFileSystem>();

            fileSystem.Setup(f => f.Exists(fileName))
            .Returns(true);

            fileSystem.Setup(f => f.ReadAllText(fileName))
            .Returns(assemblyFileContent);

            fileSystem.Setup(f => f.WriteAllText(fileName, It.IsAny <string>()))
            .Callback <string, string>((name, content) =>
            {
                fileSystem.Setup(f => f.ReadAllText(name))
                .Returns(content);
            });

            var config    = new TestEffectiveConfiguration(assemblyVersioningScheme: versioningScheme);
            var variables = version.ToVersionVariables(config);

            verify?.Invoke(fileSystem, variables);
        }
Пример #11
0
    static void VerifyAssemblyVersion(ICompiler compiler, AssemblyVersioningScheme avs, string assemblyInformationalFormat = null)
    {
        var semanticVersion = new SemanticVersion
        {
            Major         = 2,
            Minor         = 3,
            Patch         = 4,
            PreReleaseTag = "beta.5",
            BuildMetaData = new SemanticVersionBuildMetaData(6,
                                                             "master", "commitSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z")),
        };

        var config = new TestEffectiveConfiguration(assemblyVersioningScheme: avs, assemblyInformationalFormat: assemblyInformationalFormat);

        var versionVariables = VariableProvider.GetVariablesFor(semanticVersion, config, false);
        var assemblyInfoText = compiler.Builder.GetAssemblyInfoText(versionVariables, "Fake");

        assemblyInfoText.ShouldMatchApproved(c => c.UseCallerLocation().SubFolder(compiler.ApprovedSubFolder));

        var compilation = compiler.Compile(assemblyInfoText);

        var emitResult = compilation.Emit(new MemoryStream());

        Assert.IsTrue(emitResult.Success, string.Join(Environment.NewLine, emitResult.Diagnostics.Select(x => x.Descriptor)));
    }
Пример #12
0
        public void BuildNumberIsFullSemVer()
        {
            var writes          = new List <string>();
            var semanticVersion = new SemanticVersion
            {
                Major         = 1,
                Minor         = 2,
                Patch         = 3,
                PreReleaseTag = "beta1",
                BuildMetaData = "5"
            };

            semanticVersion.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");
            semanticVersion.BuildMetaData.Sha        = "commitSha";

            var config = new TestEffectiveConfiguration();

            var variables   = this.buildServer.GetVariablesFor(semanticVersion, config, false);
            var buildServer = sp.GetService <BuildAgent>();

            buildServer.WriteIntegration(writes.Add, variables);

            writes[1].ShouldBe("1.2.3-beta.1+5");

            writes = new List <string>();
            buildServer.WriteIntegration(writes.Add, variables, false);
            writes.ShouldBeEmpty();
        }
        public void FormatVersion_ShouldPromoteNumberOfCommitsToTagNumber_WhenContinuousDeployment()
        {
            var version  = SemanticVersion.Parse("1.1.0-alpha.1+3");
            var expected = SemanticVersion.Parse("1.1.0-alpha.3");

            var config    = new TestEffectiveConfiguration(versioningMode: VersioningMode.ContinuousDeployment);
            var formatted = version.FormatVersion(config);

            Assert.That(formatted, Is.EqualTo(expected));
        }
Пример #14
0
    public void ShouldStartSearchFromWorkingDirectory()
    {
        var          fileSystem = Substitute.For <IFileSystem>();
        const string workingDir = "C:\\Testing";

        var config    = new TestEffectiveConfiguration();
        var variables = VariableProvider.GetVariablesFor(SemanticVersion.Parse("1.0.0", "v"), config, false);

        using (new AssemblyInfoFileUpdate(new Arguments {
            UpdateAssemblyInfo = true
        }, workingDir, variables, fileSystem))
        {
            fileSystem.Received().DirectoryGetFiles(Arg.Is(workingDir), Arg.Any <string>(), Arg.Any <SearchOption>());
        }
    }
Пример #15
0
    public void ShouldLogWarningWhenUsingDefaultInformationalVersionInCustomFormat()
    {
        var semVer = new SemanticVersion
        {
            Major = 1,
            Minor = 2,
            Patch = 3
        };

#pragma warning disable CS0618 // Type or member is obsolete
        const string propertyName = nameof(SemanticVersionFormatValues.DefaultInformationalVersion);
#pragma warning restore CS0618 // Type or member is obsolete
        var config = new TestEffectiveConfiguration(assemblyInformationalFormat: $"{{{propertyName}}}");
        this.variableProvider.GetVariablesFor(semVer, config, false);
        this.logMessages.ShouldContain(message => message.Trim().StartsWith("WARN") && message.Contains(propertyName), 1, $"Expected a warning to be logged when using the variable {propertyName} in a configuration format template");
    }
Пример #16
0
        public void UpdateWixVersionFileWhenFileAlreadyExists()
        {
            var workingDir = Path.GetTempPath();
            var semVer     = new SemanticVersion
            {
                Major         = 1,
                Minor         = 2,
                Patch         = 3,
                BuildMetaData = "5.Branch.develop"
            };

            semVer.BuildMetaData.VersionSourceSha = "versionSourceSha";
            semVer.BuildMetaData.Sha        = "commitSha";
            semVer.BuildMetaData.ShortSha   = "commitShortSha";
            semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2019-02-20 23:59:59Z");

            var config = new TestEffectiveConfiguration(buildMetaDataPadding: 2, legacySemVerPadding: 5);

            var stringBuilder = new StringBuilder();

            void Action(string s) => stringBuilder.AppendLine(s);

            var logAppender = new TestLogAppender(Action);
            var log         = new Log(logAppender);

            var sp = ConfigureServices(service =>
            {
                service.AddSingleton <ILog>(log);
            });

            var fileSystem       = sp.GetService <IFileSystem>();
            var variableProvider = sp.GetService <IVariableProvider>();
            var versionVariables = variableProvider.GetVariablesFor(semVer, config, false);

            using var wixVersionFileUpdater = sp.GetService <IWixVersionFileUpdater>();

            // fake an already existing file
            var file = Path.Combine(workingDir, WixVersionFileUpdater.WixVersionFileName);

            fileSystem.WriteAllText(file, new string('x', 1024 * 1024));

            wixVersionFileUpdater.Execute(versionVariables, new WixVersionContext(workingDir));

            fileSystem
            .ReadAllText(file)
            .ShouldMatchApproved(c => c.SubFolder(Path.Combine("Approved")));
        }
Пример #17
0
    public void Json()
    {
        var semanticVersion = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 0,
            PreReleaseTag = "unstable4",
            BuildMetaData = new SemanticVersionBuildMetaData(5, "feature1", "commitSha", "commitShortSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z"))
        };

        var config = new TestEffectiveConfiguration();

        var variables = VariableProvider.GetVariablesFor(semanticVersion, config, false);
        var json      = JsonOutputFormatter.ToJson(variables);

        json.ShouldMatchApproved(c => c.SubFolder("Approved"));
    }
Пример #18
0
    public void ProvidesVariablesInContinuousDeploymentModeForStable()
    {
        var semVer = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            BuildMetaData = "5.Branch.develop"
        };

        semVer.BuildMetaData.Sha        = "commitSha";
        semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");

        var config = new TestEffectiveConfiguration(versioningMode: VersioningMode.ContinuousDeployment);

        var vars = VariableProvider.GetVariablesFor(semVer, config, false);

        JsonOutputFormatter.ToJson(vars).ShouldMatchApproved();
    }
    public void ProvidesVariablesInContinuousDeploymentModeWithTagSetToUseBranchName()
    {
        var semVer = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            BuildMetaData = "5.Branch.develop"
        };

        semVer.BuildMetaData.Branch     = "feature";
        semVer.BuildMetaData.Sha        = "commitSha";
        semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");

        var config = new TestEffectiveConfiguration(versioningMode: VersioningMode.ContinuousDeployment, tag: "useBranchName");
        var vars   = VariableProvider.GetVariablesFor(semVer, config, false);

        vars.FullSemVer.ShouldBe("1.2.3-feature.5");
    }
Пример #20
0
    public void CommitDateFormatTest(string format, string expectedOutcome)
    {
        var date = new DateTime(2017, 10, 6);
        var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(
            "950d2f830f5a2af12a6779a48d20dcbb02351f25",
            0,
            MainBranch,
            "3139d4eeb044f46057693473eacc2655b3b27e7d",
            "3139d4eeb",
            new DateTimeOffset(date, TimeSpan.Zero),
            0);
        var semanticVersion = new SemanticVersion
        {
            BuildMetaData = semanticVersionBuildMetaData // assume time zone is UTC
        };
        var configuration = new TestEffectiveConfiguration(commitDateFormat: format);
        var formatValues  = new SemanticVersionFormatValues(semanticVersion, configuration);

        Assert.That(formatValues.CommitDate, Is.EqualTo(expectedOutcome));
    }
    public void ProvidesVariablesInContinuousDeploymentModeWithTagNamePattern()
    {
        var semVer = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            PreReleaseTag = "PullRequest",
            BuildMetaData = "5.Branch.develop"
        };

        semVer.BuildMetaData.Branch     = "pull/2/merge";
        semVer.BuildMetaData.Sha        = "commitSha";
        semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");

        var config = new TestEffectiveConfiguration(versioningMode: VersioningMode.ContinuousDeployment, tagNumberPattern: @"[/-](?<number>\d+)[-/]");
        var vars   = VariableProvider.GetVariablesFor(semVer, config, false);

        vars.FullSemVer.ShouldBe("1.2.3-PullRequest0002.5");
    }
Пример #22
0
    public void ProvidesVariablesInContinuousDeploymentModeForStable()
    {
        var semVer = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            BuildMetaData = "5.Branch.develop"
        };

        semVer.BuildMetaData.VersionSourceSha = "versionSourceSha";
        semVer.BuildMetaData.Sha        = "commitSha";
        semVer.BuildMetaData.ShortSha   = "commitShortSha";
        semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");

        var config = new TestEffectiveConfiguration(versioningMode: VersioningMode.ContinuousDeployment);

        var vars = this.variableProvider.GetVariablesFor(semVer, config, false);

        vars.ToString().ShouldMatchApproved(c => c.SubFolder("Approved"));
    }
Пример #23
0
        public void Json()
        {
            var semanticVersion = new SemanticVersion
            {
                Major         = 1,
                Minor         = 2,
                Patch         = 0,
                PreReleaseTag = "unstable4",
                BuildMetaData = new SemanticVersionBuildMetaData("versionSourceSha", 5, "feature1", "commitSha", "commitShortSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z"), 0)
            };

            var config = new TestEffectiveConfiguration();

            var sp = ConfigureServices();

            var variableProvider = sp.GetService <IVariableProvider>();
            var variables        = variableProvider.GetVariablesFor(semanticVersion, config, false);
            var json             = variables.ToString();

            json.ShouldMatchApproved(c => c.SubFolder("Approved"));
        }
Пример #24
0
    public void ProvidesVariablesInContinuousDeliveryModeForPreReleaseWithPadding()
    {
        var semVer = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            PreReleaseTag = "unstable.4",
            BuildMetaData = "5.Branch.develop"
        };

        semVer.BuildMetaData.Sha        = "commitSha";
        semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");


        var config = new TestEffectiveConfiguration(buildMetaDataPadding: 2, legacySemVerPadding: 5);

        var vars = VariableProvider.GetVariablesFor(semVer, config, false);

        JsonOutputFormatter.ToJson(vars).ShouldMatchApproved();
    }
Пример #25
0
    public void ProvidesVariablesInContinuousDeploymentModeForStableWhenCurrentCommitIsTagged()
    {
        var semVer = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            BuildMetaData =
            {
                CommitsSinceTag =           5,
                Sha             = "commitSha",
                CommitDate      = DateTimeOffset.Parse("2014-03-06 23:59:59Z")
            }
        };

        var config = new TestEffectiveConfiguration(versioningMode: VersioningMode.ContinuousDeployment);

        var vars = VariableProvider.GetVariablesFor(semVer, config, true);

        Approvals.Verify(JsonOutputFormatter.ToJson(vars));
    }
Пример #26
0
    public void ShouldReplaceAssemblyVersionInRelativePath()
    {
        var fileSystem = Substitute.For <IFileSystem>();
        var version    = new SemanticVersion
        {
            BuildMetaData = new SemanticVersionBuildMetaData(3, "foo", "hash", DateTimeOffset.Now),
            Major         = 2,
            Minor         = 3,
            Patch         = 1
        };

        var    workingDir       = Path.GetTempPath();
        string assemblyInfoFile = Join(@"AssemblyVersion(""1.0.0.0"");",
                                       @"AssemblyInformationalVersion(""1.0.0.0"");",
                                       @"AssemblyFileVersion(""1.0.0.0"");");

        var fileName = Path.Combine(workingDir, "Project", "src", "Properties", "AssemblyInfo.cs");

        fileSystem.Exists(fileName).Returns(true);
        fileSystem.ReadAllText(fileName).Returns(assemblyInfoFile);

        var config = new TestEffectiveConfiguration(assemblyVersioningScheme: AssemblyVersioningScheme.MajorMinor);

        var variable = VariableProvider.GetVariablesFor(version, config, false);
        var args     = new Arguments
        {
            UpdateAssemblyInfo         = true,
            UpdateAssemblyInfoFileName = new HashSet <string> {
                Path.Combine("Project", "src", "Properties", "AssemblyInfo.cs")
            }
        };

        using (new AssemblyInfoFileUpdate(args, workingDir, variable, fileSystem))
        {
            string expected = Join(@"AssemblyVersion(""2.3.0.0"");",
                                   @"AssemblyInformationalVersion(""2.3.1+3.Branch.foo.Sha.hash"");",
                                   @"AssemblyFileVersion(""2.3.1.0"");");
            fileSystem.Received().WriteAllText(fileName, expected);
        }
    }
Пример #27
0
    public void ProvidesVariablesInContinuousDeliveryModeForFeatureBranchWithCustomAssemblyInfoFormat()
    {
        var semVer = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            BuildMetaData = "5.Branch.feature/123"
        };

        semVer.BuildMetaData.Branch           = "feature/123";
        semVer.BuildMetaData.VersionSourceSha = "versionSourceSha";
        semVer.BuildMetaData.Sha        = "commitSha";
        semVer.BuildMetaData.ShortSha   = "commitShortSha";
        semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");


        var config = new TestEffectiveConfiguration(assemblyInformationalFormat: "{Major}.{Minor}.{Patch}+{CommitsSinceVersionSource}.Branch.{BranchName}.Sha.{ShortSha}");

        var vars = this.variableProvider.GetVariablesFor(semVer, config, false);

        vars.ToString().ShouldMatchApproved(c => c.SubFolder("Approved"));
    }
        public void ProvidesVariablesInContinuousDeliveryModeForFeatureBranch()
        {
            var semVer = new SemanticVersion
            {
                Major         = 1,
                Minor         = 2,
                Patch         = 3,
                BuildMetaData = "5.Branch.feature/123"
            };

            semVer.BuildMetaData.Branch           = "feature/123";
            semVer.BuildMetaData.VersionSourceSha = "versionSourceSha";
            semVer.BuildMetaData.Sha        = "commitSha";
            semVer.BuildMetaData.ShortSha   = "commitShortSha";
            semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z");


            var config = new TestEffectiveConfiguration();

            var vars = variableProvider.GetVariablesFor(semVer, config, false);

            vars.ToString().ShouldMatchApproved(c => c.SubFolder("Approved"));
        }
Пример #29
0
    public void ProvidesVariablesInContinuousDeploymentModeForStableWhenCurrentCommitIsTagged()
    {
        var semVer = new SemanticVersion
        {
            Major         = 1,
            Minor         = 2,
            Patch         = 3,
            BuildMetaData = new SemanticVersionBuildMetaData
            {
                VersionSourceSha          = "versionSourceSha",
                CommitsSinceTag           = 5,
                CommitsSinceVersionSource = 5,
                Sha        = "commitSha",
                ShortSha   = "commitShortSha",
                CommitDate = DateTimeOffset.Parse("2014-03-06 23:59:59Z")
            }
        };

        var config = new TestEffectiveConfiguration(versioningMode: VersioningMode.ContinuousDeployment);

        var vars = this.variableProvider.GetVariablesFor(semVer, config, true);

        vars.ToString().ShouldMatchApproved(c => c.SubFolder("Approved"));
    }