public async Task Report_SkipsCreationIfThereIsAlreadyOpenIssue()
        {
            var report = new ValidationReport
            {
                Owner          = "owner",
                RepositoryName = "repo",
                Results        = new ValidationResult[]
                {
                    new ValidationResult("Rule", "how to fix", false, null)
                }
            };

            var issue = CreateIssue(CreateIssueTitle("Rule"), ItemState.Open);

            _mockIssuesClient.GetAllForRepository(report.Owner, report.RepositoryName, Arg.Any <RepositoryIssueRequest>()).Returns(Task.FromResult((IReadOnlyList <Issue>) new List <Issue>()
            {
                issue
            }));

            await _reporter.Report(new ValidationReport[] { report });

            await _mockIssuesClient.DidNotReceive().Create(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <NewIssue>());

            await _mockIssuesClient.DidNotReceive().Update(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int>(), Arg.Any <IssueUpdate>());
        }
예제 #2
0
        private async Task CreateIssues(IEnumerable <PortingInfo> rulesToPort)
        {
            var existingIssues = await _issuesClient.GetAllForRepository(
                _options.RepoOwner,
                _options.RepoName,
                new RepositoryIssueRequest
            {
                Filter = IssueFilter.All,       // Get issues whether or not they're assigned to me.
                State  = ItemState.All          // Get issues whether they're open or closed.
            });

            foreach (var ruleToPort in rulesToPort)
            {
                string title             = MakeIssueTitle(ruleToPort);
                var    matchingIssues    = existingIssues.Where(issue => issue.Title == title);
                int    numMatchingIssues = matchingIssues.Count();

                if (numMatchingIssues == 0)
                {
                    _log.InfoFormat(Resources.InfoFilingNewIssue, ruleToPort.Id);

                    Issue issue = FileIssueAsync(ruleToPort, title).Result;

                    // If the issue we just filed has already been dealt with, one way
                    // or another, then immediately close it. UpdateIssueAsync will do that.
                    if (ruleToPort.Disposition == Disposition.Cut || ruleToPort.Disposition == Disposition.Ported)
                    {
                        await UpdateIssueAsync(ruleToPort, issue);
                    }
                }
                else if (numMatchingIssues == 1)
                {
                    Issue existingIssue = matchingIssues.First();
                    int   issueNumber   = existingIssue.Number;

                    _log.InfoFormat(Resources.InfoUpdatingExistingIssue, issueNumber, ruleToPort.Id);

                    await UpdateIssueAsync(ruleToPort, existingIssue);
                }
                else if (numMatchingIssues > 1)
                {
                    _log.WarnFormat(
                        Resources.WarningMultipleIssuesExist,
                        ruleToPort.Id,
                        string.Join(", ", matchingIssues.Select(i => i.Number.ToString()).ToArray()));
                }

                if (_options.Delay > 0 && !_options.DryRun)
                {
                    _log.DebugFormat(Resources.DebugDelaying, _options.Delay);
                    Thread.Sleep(_options.Delay);
                }
            }
        }
        public (List <KeyValuePair <DateTime, int> >, string) GetAllIssues(string repoUrl)
        {
            if (issuesclient == null)
            {
                Setup();
            }
            repoUrl = Regex.Replace(repoUrl, ".*github.com/", "");
            string user      = Regex.Split(repoUrl, "/")[0];
            string repo      = Regex.Split(repoUrl, "/")[1];
            var    allissues = issuesclient.GetAllForRepository(user, repo, getAll).GetAwaiter().GetResult();

            Dictionary <DateTime, int> dict = new Dictionary <DateTime, int>();

            foreach (Issue issue in allissues)
            {
                DateTime       created      = new DateTime(issue.CreatedAt.Year, issue.CreatedAt.Month, issue.CreatedAt.Day, 0, 0, 0);
                DateTimeOffset closedOffset = issue.ClosedAt ?? DateTimeOffset.Now.AddDays(1);
                DateTime       closed       = new DateTime(closedOffset.Year, closedOffset.Month, closedOffset.Day, 0, 0, 0);
                Console.WriteLine("New issue");
                while (created < closed)
                {
                    if (dict.ContainsKey(created))
                    {
                        dict.TryGetValue(created, out int value);
                        dict.Remove(created);
                        dict.Add(created, ++value);
                    }
                    else
                    {
                        dict.Add(created, 1);
                    }
                    created = created.AddDays(1);
                }
            }
            var myList = dict.ToList();

            myList.Sort((pair1, pair2) => pair1.Key.CompareTo(pair2.Key));
            DateTime first = myList.ElementAt(0).Key;

            while (first <= DateTime.Now)
            {
                if (!dict.ContainsKey(first))
                {
                    myList.Add(new KeyValuePair <DateTime, int>(first, 0));
                }
                first = first.AddDays(1);
            }
            myList.Sort((pair1, pair2) => pair1.Key.CompareTo(pair2.Key));

            return(myList, repo);
        }
예제 #4
0
        public Issue GetIssueWithName(string repositorName, string ownerName, string issueName)
        {
            IReadOnlyList <Issue> issues = issuesClient.GetAllForRepository(ownerName, repositorName).GetAwaiter().GetResult();

            return(issues.FirstOrDefault(i =>
            {
                if (i.Title.Equals(issueName))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }));
        }
예제 #5
0
        private bool DoesIssueExist(string issueTitle)
        {
            var repositoryIssueRequest = new RepositoryIssueRequest
            {
                State = ItemStateFilter.All
            };

            foreach (var label in _issueLabels)
            {
                repositoryIssueRequest.Labels.Add(label);
            }
            var task = _issuesClient.GetAllForRepository(_gitHubRepoInfo.Owner, _gitHubRepoInfo.Name, repositoryIssueRequest);

            task.Wait();
            var issues = task.Result;

            if (issues == null)
            {
                return(false);                //Not sure what happened, let's just upload the report.
            }
            return(issues.Any(i => i.Title == issueTitle));
        }
    public async Task CanCreateRetrieveAndCloseIssue()
    {
        var newIssue = new NewIssue("a test issue")
        {
            Body = "A new unassigned issue"
        };
        var issue = await _issuesClient.Create(_context.RepositoryOwner, _context.RepositoryName, newIssue);

        try
        {
            Assert.NotNull(issue);

            var retrieved = await _issuesClient.Get(_context.RepositoryOwner, _context.RepositoryName, issue.Number);

            var all = await _issuesClient.GetAllForRepository(_context.RepositoryOwner, _context.RepositoryName);

            Assert.NotNull(retrieved);
            Assert.True(all.Any(i => i.Number == retrieved.Number));
        }
        finally
        {
            var closed = _issuesClient.Update(_context.RepositoryOwner, _context.RepositoryName, issue.Number,
                                              new IssueUpdate {
                State = ItemState.Closed
            })
                         .Result;
            Assert.NotNull(closed);
        }
    }
    public async Task ReturnsPageOfIssuesForARepository()
    {
        var options = new ApiOptions
        {
            PageSize  = 5,
            PageCount = 1
        };

        var issues = await _issuesClient.GetAllForRepository("libgit2", "libgit2sharp", options);

        Assert.Equal(5, issues.Count);
    }