public void Should_Return_Correct_Value(
                string filePath,
                int?line,
                string message,
                int priority,
                string rule,
                string ruleUrl,
                string expectedResult)
            {
                // Given
                Uri ruleUri = null;

                if (!string.IsNullOrWhiteSpace(ruleUrl))
                {
                    ruleUri = new Uri(ruleUrl);
                }

                var issue = new CodeAnalysisIssue(filePath, line, message, priority, rule, ruleUri, "Foo");

                // When
                var result = ContentProvider.GetContent(issue);

                // Then
                result.ShouldBe(expectedResult);
            }
            public void Should_Handle_File_Paths_Which_Are_WhiteSpace()
            {
                // Given / When
                var issue = new CodeAnalysisIssue <FakeCodeAnalysisProvider>(" ", null, "Foo", 1, "Bar", new Uri("https://google.com"));

                // Then
                issue.AffectedFileRelativePath.ShouldBe(null);
            }
예제 #3
0
            public void Should_Set_ProviderType(string providerType)
            {
                // Given / When
                var issue = new CodeAnalysisIssue(@"foo.cs", 100, "foo", 1, "foo", providerType);

                // Then
                issue.ProviderType.ShouldBe(providerType);
            }
            public void Should_Set_Line(int?line)
            {
                // Given / When
                var issue = new CodeAnalysisIssue <FakeCodeAnalysisProvider>(@"foo.cs", line, "Foo", 1, "Bar", new Uri("https://google.com"));

                // Then
                issue.Line.ShouldBe(line);
            }
예제 #5
0
            public void Should_Set_Line(int?line)
            {
                // Given / When
                var issue = new CodeAnalysisIssue(@"foo.cs", line, "Foo", 1, "Bar", "foo");

                // Then
                issue.Line.ShouldBe(line);
            }
예제 #6
0
            public void Should_Handle_File_Paths_Which_Are_WhiteSpace()
            {
                // Given / When
                var issue = new CodeAnalysisIssue(" ", null, "Foo", 1, "Bar", "foo");

                // Then
                issue.AffectedFileRelativePath.ShouldBe(null);
            }
            public void Should_Handle_File_Paths_Which_Are_Empty()
            {
                // Given / When
                var issue = new CodeAnalysisIssue <FakeCodeAnalysisProvider>(string.Empty, null, "Foo", 1, "Bar");

                // Then
                issue.AffectedFileRelativePath.ShouldBe(null);
            }
예제 #8
0
            public void Should_Set_Rule(string rule)
            {
                // Given / When
                var issue = new CodeAnalysisIssue(@"foo.cs", 100, "foo", 1, rule, "foo");

                // Then
                issue.Rule.ShouldBe(rule);
            }
            public void Should_Set_ProviderType()
            {
                // Given / When
                var issue = new CodeAnalysisIssue <FakeCodeAnalysisProvider>(@"foo.cs", 100, "foo", 1, "foo", new Uri("https://google.com"));

                // Then
                issue.ProviderType.ShouldBe("Cake.Prca.Tests.FakeCodeAnalysisProvider");
            }
            public void Should_Set_Rule(string rule)
            {
                // Given / When
                var issue = new CodeAnalysisIssue <FakeCodeAnalysisProvider>(@"foo.cs", 100, "foo", 1, rule, new Uri("https://google.com"));

                // Then
                issue.Rule.ShouldBe(rule);
            }
            public void Should_Set_Message(string message)
            {
                // Given / When
                var issue = new CodeAnalysisIssue <FakeCodeAnalysisProvider>(@"foo.cs", 100, message, 1, "Bar", new Uri("https://google.com"));

                // Then
                issue.Message.ShouldBe(message);
            }
예제 #12
0
            public void Should_Set_Message(string message)
            {
                // Given / When
                var issue = new CodeAnalysisIssue(@"foo.cs", 100, message, 1, "Bar", "foo");

                // Then
                issue.Message.ShouldBe(message);
            }
예제 #13
0
            public void Should_Set_File_Path(string filePath, string expectedFilePath)
            {
                // Given / When
                var issue = new CodeAnalysisIssue(filePath, 100, "Foo", 1, "Bar", "foo");

                // Then
                issue.AffectedFileRelativePath.ToString().ShouldBe(expectedFilePath);
                issue.AffectedFileRelativePath.IsRelative.ShouldBe(true, "File path was not set as relative.");
            }
            public void Should_Set_File_Path(string filePath, string expectedFilePath)
            {
                // Given / When
                var issue = new CodeAnalysisIssue <FakeCodeAnalysisProvider>(filePath, 100, "Foo", 1, "Bar", new Uri("https://google.com"));

                // Then
                issue.AffectedFileRelativePath.ToString().ShouldBe(expectedFilePath);
                issue.AffectedFileRelativePath.IsRelative.ShouldBe(true, "File path was not set as relative.");
            }
예제 #15
0
            public void Should_Set_Rule_Url()
            {
                // Given
                var ruleUrl = new Uri("http://google.com");

                // When
                var issue = new CodeAnalysisIssue(@"foo.cs", 100, "foo", 1, "foo", ruleUrl, "foo");

                // Then
                issue.RuleUrl.ShouldBe(ruleUrl);
            }
예제 #16
0
            public void Should_Set_Rule_Url_If_Null()
            {
                // Given
                Uri ruleUrl = null;

                // When
                var issue = new CodeAnalysisIssue(@"foo.cs", 100, "foo", 1, "foo", ruleUrl, "foo");

                // Then
                issue.RuleUrl.ShouldBe(ruleUrl);
            }
예제 #17
0
            public void Should_Return_Reported_Issues_If_PullRequestSystem_Could_Not_Be_Initialized()
            {
                // Given
                var firstIssue =
                    new CodeAnalysisIssue(
                        @"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs",
                        10,
                        "Foo",
                        0,
                        "Foo",
                        "Foo");
                var secondIssue =
                    new CodeAnalysisIssue(
                        @"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs",
                        10,
                        "Foo",
                        0,
                        "Foo",
                        "Foo");
                var fixture = new PrcaFixture();

                fixture.CodeAnalysisProviders.Clear();
                fixture.CodeAnalysisProviders.Add(
                    new FakeCodeAnalysisProvider(
                        fixture.Log,
                        new List <ICodeAnalysisIssue>
                {
                    firstIssue, secondIssue
                }));

                fixture.PullRequestSystem =
                    new FakePullRequestSystem(
                        fixture.Log,
                        new List <IPrcaDiscussionThread>(),
                        new List <FilePath>
                {
                    new FilePath(@"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs")
                })
                {
                    ShouldFailOnInitialization = true
                };

                fixture.ReportIssuesToPullRequestSettings.MaxIssuesToPost = 1;

                // When
                var result = fixture.RunOrchestrator();

                // Then
                result.ReportedIssues.Count().ShouldBe(2);
                result.ReportedIssues.ShouldContain(firstIssue);
                result.ReportedIssues.ShouldContain(secondIssue);
                result.PostedIssues.Count().ShouldBe(0);
            }
예제 #18
0
            public void Should_Return_Correct_Values()
            {
                // Given
                var reportedIssue =
                    new CodeAnalysisIssue(
                        @"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs",
                        10,
                        "Foo",
                        0,
                        "Foo",
                        "Foo");
                var postedIssue =
                    new CodeAnalysisIssue(
                        @"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs",
                        10,
                        "Foo",
                        0,
                        "Foo",
                        "Foo");
                var fixture = new PrcaFixture();

                fixture.CodeAnalysisProviders.Clear();
                fixture.CodeAnalysisProviders.Add(
                    new FakeCodeAnalysisProvider(
                        fixture.Log,
                        new List <ICodeAnalysisIssue>
                {
                    postedIssue, reportedIssue
                }));

                fixture.PullRequestSystem =
                    new FakePullRequestSystem(
                        fixture.Log,
                        new List <IPrcaDiscussionThread>(),
                        new List <FilePath>
                {
                    new FilePath(@"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs")
                });

                fixture.ReportIssuesToPullRequestSettings.MaxIssuesToPost = 1;

                // When
                var result = fixture.RunOrchestrator();

                // Then
                result.ReportedIssues.Count().ShouldBe(2);
                result.ReportedIssues.ShouldContain(reportedIssue);
                result.ReportedIssues.ShouldContain(postedIssue);
                result.PostedIssues.Count().ShouldBe(1);
                result.PostedIssues.ShouldContain(postedIssue);
            }
예제 #19
0
            public void Should_Post_Issue_Not_Related_To_A_File()
            {
                // Given
                var issueToPost =
                    new CodeAnalysisIssue(
                        null,
                        null,
                        "Foo",
                        0,
                        "Foo",
                        "Foo");

                var fixture = new PrcaFixture();

                fixture.CodeAnalysisProviders.Clear();
                fixture.CodeAnalysisProviders.Add(
                    new FakeCodeAnalysisProvider(
                        fixture.Log,
                        new List <ICodeAnalysisIssue>
                {
                    issueToPost
                }));

                fixture.PullRequestSystem =
                    new FakePullRequestSystem(
                        fixture.Log,
                        new List <IPrcaDiscussionThread>(),
                        new List <FilePath>
                {
                    new FilePath(@"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs")
                });

                // When
                fixture.RunOrchestrator();

                // Then
                fixture.PullRequestSystem.PostedIssues.ShouldContain(issueToPost);
                fixture.Log.Entries.ShouldContain(
                    x =>
                    x.Message ==
                    $"Posting 1 issue(s):\n  Rule: {issueToPost.Rule} Line: {issueToPost.Line} File: {issueToPost.AffectedFileRelativePath}");
            }
예제 #20
0
            public void Should_Read_Correct_Number_Of_Code_Analysis_Issues_Not_Related_To_A_File()
            {
                // Given
                var issue1 =
                    new CodeAnalysisIssue(
                        null,
                        null,
                        "Foo",
                        0,
                        "Foo",
                        "Foo");
                var issue2 =
                    new CodeAnalysisIssue(
                        null,
                        null,
                        "Bar",
                        0,
                        "Bar",
                        "Bar");
                var fixture = new PrcaFixture();

                fixture.CodeAnalysisProviders.Clear();
                fixture.CodeAnalysisProviders.Add(
                    new FakeCodeAnalysisProvider(
                        fixture.Log,
                        new List <ICodeAnalysisIssue>
                {
                    issue1,
                    issue2
                }));

                // When
                var issues = fixture.ReadIssues(PrcaCommentFormat.Undefined).ToList();

                // Then
                issues.Count.ShouldBe(2);
                issues.ShouldContain(issue1);
                issues.ShouldContain(issue2);
            }
예제 #21
0
            public void Should_Read_Correct_Number_Of_Code_Analysis_Issues_From_Multiple_Providers()
            {
                // Given
                var issue1 =
                    new CodeAnalysisIssue(
                        @"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs",
                        10,
                        "Foo",
                        0,
                        "Foo",
                        "Foo");
                var issue2 =
                    new CodeAnalysisIssue(
                        @"src\Cake.Prca.Tests\FakeCodeAnalysisProvider.cs",
                        12,
                        "Bar",
                        0,
                        "Bar",
                        "Bar");
                var issue3 =
                    new CodeAnalysisIssue(
                        @"src\Cake.Prca.Tests\Foo.cs",
                        5,
                        "Foo",
                        0,
                        "Foo",
                        "Foo");
                var issue4 =
                    new CodeAnalysisIssue(
                        @"src\Cake.Prca.Tests\Bar.cs",
                        7,
                        "Bar",
                        0,
                        "Bar",
                        "Bar");
                var fixture = new PrcaFixture();

                fixture.CodeAnalysisProviders.Clear();
                fixture.CodeAnalysisProviders.Add(
                    new FakeCodeAnalysisProvider(
                        fixture.Log,
                        new List <ICodeAnalysisIssue>
                {
                    issue1,
                    issue2
                }));
                fixture.CodeAnalysisProviders.Add(
                    new FakeCodeAnalysisProvider(
                        fixture.Log,
                        new List <ICodeAnalysisIssue>
                {
                    issue3,
                    issue4
                }));

                // When
                var issues = fixture.ReadIssues(PrcaCommentFormat.Undefined).ToList();

                // Then
                issues.Count.ShouldBe(4);
                issues.ShouldContain(issue1);
                issues.ShouldContain(issue2);
                issues.ShouldContain(issue3);
                issues.ShouldContain(issue4);
            }