Example #1
0
        public void BuildTreeWithUpdatesStatusShouldNotProduceDeltaForDifferentStatus(BuildStatus expectedResult, PartialSucceededTreatmentMode partialSucceededTreatmentMode)
        {
            // Arrange
            var sut = Construct(GroupDefinition.Source, GroupDefinition.Branch, GroupDefinition.BuildDefinition);

            var ciDefinition = Substitute.For <IBuildDefinition>();
            var stageBranch  = Substitute.For <IBranch>();

            var builds = new List <IBuild>();

            var build1 = CreateBuild(ciDefinition, stageBranch, "1");

            builds.Add(build1);

            var build2 = CreateBuild(ciDefinition, stageBranch, "2");

            builds.Add(build2);

            var build3 = CreateBuild(ciDefinition, stageBranch, "3");

            builds.Add(build3);

            // Act
            var firstResult = sut.Build(builds);
            var newBuild2   = CreateBuild(ciDefinition, stageBranch, "2");

            newBuild2.Status.Returns(expectedResult);

            var updatedBuilds = new List <IBuild> {
                build1, newBuild2, build3
            };
            var newTree           = sut.Build(updatedBuilds);
            var currentBuildNodes = newTree.AllChildren().OfType <IBuildNode>();

            var oldStatus = firstResult.AllChildren().OfType <IBuildNode>().ToDictionary(x => x.Build.CacheKey(), x => x.Status);
            var delta     = new BuildTreeBuildsDelta(currentBuildNodes, oldStatus, partialSucceededTreatmentMode);

            // Assert
            switch (expectedResult)
            {
            case BuildStatus.Cancelled:
                Assert.Empty(delta.Succeeded);
                Assert.Empty(delta.Failed);
                break;

            case BuildStatus.Succeeded:
                Assert.Empty(delta.Failed);
                Assert.Empty(delta.Cancelled);
                break;

            case BuildStatus.PartiallySucceeded:
                if (partialSucceededTreatmentMode == PartialSucceededTreatmentMode.TreatAsSucceeded)
                {
                    Assert.Empty(delta.Failed);
                    Assert.Empty(delta.Cancelled);
                }
                else if (partialSucceededTreatmentMode == PartialSucceededTreatmentMode.TreatAsFailed)
                {
                    Assert.Empty(delta.Succeeded);
                    Assert.Empty(delta.Cancelled);
                }
                else
                {
                    Assert.Empty(delta.Succeeded);
                    Assert.Empty(delta.Failed);
                    Assert.Empty(delta.Cancelled);
                }

                break;

            case BuildStatus.Failed:
                Assert.Empty(delta.Succeeded);
                Assert.Empty(delta.Cancelled);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(expectedResult), expectedResult, null);
            }
        }
Example #2
0
        public BuildTreeBuildsDelta(IEnumerable <IBuildNode> currentBuildNodes, IReadOnlyDictionary <CacheKey, BuildStatus>?previousStatesOfBuildIds, PartialSucceededTreatmentMode partialSucceededTreatmentMode)
        {
            // without information of the previous state, a delta is not possible to calculate
            if (previousStatesOfBuildIds == null)
            {
                return;
            }

            foreach (var newBuild in currentBuildNodes)
            {
                if (previousStatesOfBuildIds.TryGetValue(newBuild.Build.CacheKey(), out var previousStatus))
                {
                    if (previousStatus != newBuild.Status)
                    {
                        AddToDelta(newBuild);
                    }
                }
                else
                {
                    AddToDelta(newBuild);
                }
            }

            void AddToDelta(IBuildNode buildNode)
            {
                switch (buildNode.Status)
                {
                case BuildStatus.Cancelled:
                    CancelledBuilds.Add(buildNode);
                    break;

                case BuildStatus.Failed:
                    FailedBuilds.Add(buildNode);
                    break;

                case BuildStatus.Succeeded:
                    SucceededBuilds.Add(buildNode);
                    break;

                case BuildStatus.PartiallySucceeded:
                    switch (partialSucceededTreatmentMode)
                    {
                    case PartialSucceededTreatmentMode.TreatAsSucceeded:
                        SucceededBuilds.Add(buildNode);
                        break;

                    case PartialSucceededTreatmentMode.TreatAsFailed:
                        FailedBuilds.Add(buildNode);
                        break;
                    }

                    break;
                }
            }
        }