Beispiel #1
0
        private IEnumerable<BuildInfoDto> GetBuildsForPollingSince(string teamProjectName, string teamProjectId, DateTime finishTime)
        {
            List<BuildInfoDto> dtos = new List<BuildInfoDto>();
            try
            {
                var polledBuilds = GetPolledBuilds(teamProjectName, finishTime);
                Parallel.ForEach(polledBuilds, new ParallelOptions { MaxDegreeOfParallelism = DegreeOfParallelism }, build =>
                {
                    var buildInfoDto = new BuildInfoDto
                    {
                        TeamProject = teamProjectName,
                        Status = build.Result ?? build.Status,
                        Builddefinition = build.Definition.Name,
                        StartBuildDateTime = build.StartTime,
                        FinishBuildDateTime = build.FinishTime,
                        RequestedByName = build.RequestedFor.DisplayName,
                        RequestedByPictureUrl = build.RequestedFor.ImageUrl + "&size=2",
                        TotalNumberOfTests = 0,
                        PassedNumberOfTests = 0,
                        BuildReportUrl = _helperClass.ConvertReportUrl(teamProjectName, build.Uri, true),
                        Id = "VSO" + teamProjectId + build.Definition.Id
                    };

                    if(buildInfoDto.RequestedByName.StartsWith("[DefaultCollection]"))
                    {
                        buildInfoDto.RequestedByName = "Service Account";
                    }

                    if (build.Status.Equals(Enum.GetName(typeof(StatusEnum.Statuses), StatusEnum.Statuses.inProgress)))
                    {
                        buildInfoDto.BuildReportUrl = _helperClass.ConvertReportUrl(teamProjectName, build.Uri, true);
                        var lastBuildTime = GetLastBuildTime(teamProjectName, build);
                        buildInfoDto.Status = StatusEnum.Statuses.inProgress.ToString();
                        if (lastBuildTime != null)
                        {
                            buildInfoDto.LastBuildTime = lastBuildTime.FinishTime - lastBuildTime.StartTime;
                        }
                    }

                    TrySetTestResults(build, teamProjectName, buildInfoDto);
                    
                    lock (dtos)
                    {
                        dtos.Add(buildInfoDto);
                    }
                });
            }
            catch (Exception e)
            {
                LogService.WriteError(e);
                throw;
            }
            return dtos;
        }
Beispiel #2
0
        private BuildInfoDto GetLatestBuild(string teamProjectName, string bdId, string bdUri, string bdName, string teamProjectId)
        {

            BuildInfoDto buildInfoDto = null;
            try
            {
                var latestBuild =
                    _helperClass
                        .RetrieveTask<Build>(
                        (String.Format(_configurationRestService.RetrieveLastBuildAsyncUrl, teamProjectName, bdId)))
                        .Result
                        .FirstOrDefault();
                if (latestBuild == null) return null;
                buildInfoDto = new BuildInfoDto
                {
                    TeamProject = teamProjectName,
                    Status = latestBuild.Result ?? latestBuild.Status,
                    Builddefinition = bdName,
                    StartBuildDateTime = latestBuild.StartTime,
                    FinishBuildDateTime = latestBuild.FinishTime,
                    RequestedByName = latestBuild.RequestedFor.DisplayName,
                    RequestedByPictureUrl = latestBuild.RequestedFor.ImageUrl + "&size=2",
                    TotalNumberOfTests = 0,
                    PassedNumberOfTests = 0,
                    BuildReportUrl = _helperClass.ConvertReportUrl(teamProjectName, latestBuild.Uri, true),
                    Id = "VSO" + teamProjectId + bdId
                };

                if (buildInfoDto.RequestedByName.StartsWith("[DefaultCollection]"))
                {
                    buildInfoDto.RequestedByName = "Service Account";
                }

                if (latestBuild.Status.Equals(Enum.GetName(typeof(StatusEnum.Statuses), StatusEnum.Statuses.inProgress)))
                {
                    buildInfoDto.BuildReportUrl = _helperClass.ConvertReportUrl(teamProjectName, latestBuild.Uri, true);
                    buildInfoDto.Status = StatusEnum.Statuses.inProgress.ToString();
                    var secondLastBuild = GetLastBuildTime(teamProjectName, latestBuild);
                        // _helperClass.RetrieveTask<Build>(
                        //(String.Format(_configurationRestService.RetrieveLastSuccessfulBuildUrl, teamProjectName, bdUri))).Result;

                    
                    if (secondLastBuild != null)
                    {
                        buildInfoDto.LastBuildTime = secondLastBuild.FinishTime - secondLastBuild.StartTime;
                    }
                }
                
                TrySetTestResults(latestBuild, teamProjectName, buildInfoDto);
            }
            catch (Exception e)
            {
                LogService.WriteError(e);
                throw;
            }

            return buildInfoDto;
        }
Beispiel #3
0
        private void SetTestDetails(BuildInfoDto buildInfoDto, string teamProjectName, string buildUri)
        {
            var readOnlyCollection = GetTestRunDetails(teamProjectName, buildUri);

            var totalPassedTests = 0;
            var totalNumberOfTests = 0;


            if (readOnlyCollection.All(x => x.RunStatistics != null))
            {
                var runStatisticses = readOnlyCollection.SelectMany(x => x.RunStatistics).ToList();
                totalPassedTests = runStatisticses.Where(x => x.Outcome == StatusEnum.RunStatisticsStatus.Passed.ToString()).Sum(x => x.Count);
                totalNumberOfTests = runStatisticses.Sum(x => x.Count);
            }
            else
            {
                totalPassedTests = readOnlyCollection.Sum(x => x.PassedTests);
                totalNumberOfTests = readOnlyCollection.Sum(x => x.TotalTests);
            }

            buildInfoDto.TotalNumberOfTests = totalNumberOfTests;
            buildInfoDto.PassedNumberOfTests = totalPassedTests;
            if (totalNumberOfTests > 0 && totalNumberOfTests != totalPassedTests)
            {
                buildInfoDto.Status = StatusEnum.Statuses.partiallySucceeded.ToString();
            }
        }
Beispiel #4
0
 private void TrySetTestResults(Build build, string teamProjectName, BuildInfoDto buildInfoDto)
 {
     if (build.Result != null &&
            (
            build.Result.Equals(Enum.GetName(typeof(StatusEnum.Statuses), StatusEnum.Statuses.partiallySucceeded)) ||
            build.Result.Equals(Enum.GetName(typeof(StatusEnum.Statuses), StatusEnum.Statuses.failed)) 
            )
            )
     {
         SetTestDetails(buildInfoDto, teamProjectName, build.Uri);
     }
 }
Beispiel #5
0
        private BuildInfoDto GetLatestBuild(string teamProjectName, string bdId, string bdUri, string bdName, string teamProjectId)
        {
            BuildInfoDto buildInfoDto = null;
            try
            {
                var latestBuild =
                    _helperClass
                        .RetrieveTask<Build>(
                        (String.Format(_configurationRestService.RetrieveLastBuildAsyncUrl, teamProjectName, bdUri)))
                        .Result
                        .FirstOrDefault();
                if (latestBuild == null) return null;
                buildInfoDto = new BuildInfoDto
                {
                    TeamProject = teamProjectName,
                    Status = latestBuild.Status,
                    Builddefinition = bdName,
                    StartBuildDateTime = latestBuild.StartTime,
                    FinishBuildDateTime = latestBuild.FinishTime,
                    RequestedByName = latestBuild.Requests.First().RequestedFor.DisplayName,
                    RequestedByPictureUrl = latestBuild.Requests.First().RequestedFor.ImageUrl + "&size=2",
                    TotalNumberOfTests = 0,
                    PassedNumberOfTests = 0,
                    BuildReportUrl = _helperClass.ConvertReportUrl(teamProjectName, latestBuild.Uri, true),
                    Id = "VSO" + teamProjectId + bdId
                };
                if (latestBuild.Status.Equals(Enum.GetName(typeof(StatusEnum.Statuses), StatusEnum.Statuses.inProgress)))
                {
                    buildInfoDto.BuildReportUrl = _helperClass.ConvertReportUrl(teamProjectName, latestBuild.Uri, false);
                    var secondLastBuildList =
                         _helperClass.RetrieveTask<Build>(
                        (String.Format(_configurationRestService.RetrieveLastSuccessfulBuildUrl, teamProjectName, bdUri))).Result;

                    var secondLastBuild = secondLastBuildList.FirstOrDefault();
                    if (secondLastBuild != null)
                    {
                        buildInfoDto.LastBuildTime = secondLastBuild.FinishTime - secondLastBuild.StartTime;
                    }

                }
                if (latestBuild.Status.Equals(Enum.GetName(typeof(StatusEnum.Statuses), StatusEnum.Statuses.partiallySucceeded)))
                {
                    var results = GetTestResults(teamProjectName, latestBuild.Uri);
                    if (results != null)
                    {
                        buildInfoDto.TotalNumberOfTests = results.Count;
                        buildInfoDto.PassedNumberOfTests =
                            results.Count(r => r.Outcome.ToLower().Equals("passed"));
                    }
                }
            }
            catch (Exception e)
            {
                LogService.WriteError(e);
                throw;
            }

            return buildInfoDto;
        }
 private IEnumerable<BuildInfoDto> GetBuildsForPollingSince(string teamProjectName, string teamProjectId, DateTime finishTime)
 {
     List<BuildInfoDto> dtos = new List<BuildInfoDto>();
     try
     {
         var polledBuilds = GetPolledBuilds(teamProjectName, finishTime);
         Parallel.ForEach(polledBuilds, new ParallelOptions { MaxDegreeOfParallelism = DegreeOfParallelism }, build =>
         {
             var buildInfoDto = new BuildInfoDto
             {
                 TeamProject = teamProjectName,
                 Status = build.Status,
                 Builddefinition = build.Definition.Name,
                 StartBuildDateTime = build.StartTime,
                 FinishBuildDateTime = build.FinishTime,
                 RequestedByName = build.Requests.First().RequestedFor.DisplayName,
                 RequestedByPictureUrl = build.Requests.First().RequestedFor.ImageUrl,
                 TotalNumberOfTests = 0,
                 PassedNumberOfTests = 0,
                 BuildReportUrl = _helperClass.ConvertReportUrl(teamProjectName, build.Uri, true),
                 Id = "VSO" + teamProjectId + build.Definition.Id
             };
             if (build.Status.Equals(Enum.GetName(typeof(StatusEnum.Statuses), StatusEnum.Statuses.inProgress)))
             {
                 buildInfoDto.BuildReportUrl = _helperClass.ConvertReportUrl(teamProjectName, build.Uri, false);
                 var lastBuildTime = GetLastBuildTime(teamProjectName, build);
                 if (lastBuildTime != null)
                 {
                     buildInfoDto.LastBuildTime = lastBuildTime.FinishTime - lastBuildTime.StartTime;
                 }
             }
             if (
                 build.Status.Equals(Enum.GetName(typeof(StatusEnum.Statuses),
                     StatusEnum.Statuses.partiallySucceeded)))
             {
                 var results = GetTestResults(teamProjectName, build.Uri);
                 if (results != null)
                 {
                     buildInfoDto.TotalNumberOfTests = results.Count;
                     buildInfoDto.PassedNumberOfTests =
                         results.Count(r => r.Outcome.ToLower().Equals("passed"));
                 }
             }
             lock (dtos)
             {
                 dtos.Add(buildInfoDto);
             }
         });
     }
     catch (Exception e)
     {
         LogService.WriteError(e);
         throw;
     }
     return dtos;
 }
Beispiel #7
0
        private IEnumerable<BuildInfoDto> GetBuildInfoDtosPerBuildDefinition(List<IBuildDefinition> buildDefinitionList,
            IBuildServer buildServer, CatalogNode teamProjectNode,
            TfsTeamProjectCollection teamProjectCollection, ITestManagementService testService, DateTime filterDate)
        {
            var buildDtos = new List<BuildInfoDto>();
            try
            {
                Parallel.ForEach(buildDefinitionList, def =>
                {
                    var build = GetBuild(buildServer, teamProjectNode, def, filterDate);

                    if (build == null) return;

                    var buildInfoDto = new BuildInfoDto
                    {
                        Builddefinition = def.Name,
                        FinishBuildDateTime = build.FinishTime,
                        LastBuildTime = new TimeSpan(),
                        PassedNumberOfTests = 0,
                        RequestedByName = build.RequestedFor,
                        RequestedByPictureUrl = "",
                        StartBuildDateTime = build.StartTime,
                        Status = Char.ToLowerInvariant(build.Status.ToString()[0]) + build.Status.ToString().Substring(1),
                        TeamProject = teamProjectNode.Resource.DisplayName,
                        TeamProjectCollection = teamProjectCollection.Name,
                        TotalNumberOfTests = 0,
                        Id = "TFS" + teamProjectNode.Resource.Identifier + def.Id,
                        BuildReportUrl = _helperClass.GetReportUrl(teamProjectCollection.Uri.ToString(), teamProjectNode.Resource.DisplayName, build.Uri.OriginalString)
                    };
                    //Retrieve testruns
                    var testResults = GetTestResults(teamProjectNode, testService, build);

                    if (testResults.ContainsKey("PassedTests"))
                    {
                        buildInfoDto.PassedNumberOfTests = testResults["PassedTests"];
                        buildInfoDto.TotalNumberOfTests = testResults["TotalTests"];
                    }
                    //Add last succeeded build if in progress
                    if (build.Status == BuildStatus.InProgress)
                    {
                        buildInfoDto.LastBuildTime = GetLastSuccesfulBuildTime(buildServer, teamProjectNode, def);
                    }
                    lock (buildDtos)
                    {
                        buildDtos.Add(buildInfoDto);
                    }
                });
            }
            catch (Exception e)
            {
                LogService.WriteError(e);
                throw;
            }

            return buildDtos;
        }
Beispiel #8
0
        private async Task<IEnumerable<BuildInfoDto>> GetBuildInfoDtosPerBuildDefinitionRest(TfsTeamProjectCollection teamProjectCollection, IList<DefinitionReference> definitionReferences, BuildHttpClient httpClient)
        {
            try
            {

           
            var buildInfoDtos = new List<BuildInfoDto>();
            foreach (var definitionReference in definitionReferences)
            {
                var builds = await httpClient.GetBuildsAsync(top: 1, project: definitionReference.Project.Id, minFinishTime: DateTime.Now.AddMonths(-6),  definitions: new[] { definitionReference.Id }).ConfigureAwait(false);
                var build = builds.FirstOrDefault();

                if (build == null) continue;

                var buildInfoDto = new BuildInfoDto();

                buildInfoDto.Builddefinition = definitionReference.Name;
                buildInfoDto.FinishBuildDateTime = build.FinishTime.GetValueOrDefault();
                buildInfoDto.LastBuildTime = new TimeSpan();
                buildInfoDto.PassedNumberOfTests = 0;
                buildInfoDto.RequestedByName = build.RequestedFor.DisplayName;
                buildInfoDto.RequestedByPictureUrl = build.RequestedFor.ImageUrl;
                buildInfoDto.StartBuildDateTime = build.StartTime.GetValueOrDefault();
                buildInfoDto.Status = build.Result.HasValue ?
                        Char.ToLowerInvariant(build.Result.ToString()[0]) + build.Result.ToString().Substring(1)
                    : Char.ToLowerInvariant(build.Status.ToString()[0]) + build.Status.ToString().Substring(1);
                    
                buildInfoDto.TeamProject = definitionReference.Project.Name;
                buildInfoDto.TeamProjectCollection = teamProjectCollection.DisplayName;
                buildInfoDto.TotalNumberOfTests = 0;
                buildInfoDto.Id = "TFS" + definitionReference.Project.Id + definitionReference.Id;

                if (build.Uri == null)
                {
                    continue;
                }

                buildInfoDto.BuildReportUrl = _helperClass.GetReportUrl(teamProjectCollection.Uri != null ? teamProjectCollection.Uri.ToString() : "", definitionReference.Project.Name, build.Uri.ToString());

                if (build.Result.HasValue && build.Result.Value == BuildResult.PartiallySucceeded)
                {
                    var testResults = GetTestResultsRest(teamProjectCollection, definitionReference, build);

                    if (testResults.ContainsKey("PassedTests"))
                    {
                        buildInfoDto.PassedNumberOfTests = testResults["PassedTests"];
                        buildInfoDto.TotalNumberOfTests = testResults["TotalTests"];
                    }
                }

                //Add last succeeded build if in progress
                if (build.Status.HasValue && build.Status.Value == Microsoft.TeamFoundation.Build.WebApi.BuildStatus.InProgress)
                {
                    buildInfoDto.LastBuildTime = await GetLastSuccesfulBuildTimeRest(teamProjectCollection, definitionReference, httpClient).ConfigureAwait(false);
                }

                lock (buildInfoDtos)
                {
                    buildInfoDtos.Add(buildInfoDto);
                }
            }

            return buildInfoDtos;
            }
            catch (Exception exception)
            {
                LogService.WriteError(exception);
                throw;
            }
        }