HttpClient.Resilience.Analyzers/tests/HttpClient.Resilience.Analyzers.Tests/CodeFixes/UsingDeclarationEscapeGateTests.cs at e6c9ae7ddc9eb6062fabf69ad4fad729edadd54c · georgepwall1991/HttpClient.Resilience.Analyzers · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
using System.Linq;
using System.Threading.Tasks;
using HttpClient.Resilience.Analyzers.CodeFixes;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Xunit;

namespace HttpClient.Resilience.Analyzers.Tests.CodeFixes;

public sealed class UsingDeclarationEscapeGateTests
{
    [Fact]
    public async Task EmptyName_NeverEscapes()
    {
        var declaration = ParseResponseDeclaration("return Task.FromResult(0);");

        Assert.False(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, string.Empty));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task DetachedNode_NeverEscapes()
    {
        var detached = SyntaxFactory.IdentifierName("response");

        Assert.False(UsingDeclarationEscapeGate.VariableEscapesScope(detached, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task ReturnedIdentifier_Escapes()
    {
        var declaration = ParseResponseDeclaration("return response;");

        Assert.True(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task ReturnedTuple_Escapes()
    {
        var declaration = ParseResponseDeclaration("return (response, 1);");

        Assert.True(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task StoredIntoMember_Escapes()
    {
        var declaration = ParseResponseDeclaration("this.pending = response;");

        Assert.True(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task PassedAsArgument_Escapes()
    {
        var declaration = ParseResponseDeclaration("Takes(response);");

        Assert.True(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task ParenthesizedArgument_Escapes()
    {
        var declaration = ParseResponseDeclaration("Takes((response));");

        Assert.True(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }
    [Fact]
    public async Task ObjectInitializerMember_Escapes()
    {
        var declaration = ParseResponseDeclaration("var holder = new Holder { Value = response };");

        Assert.True(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task CollectionInitializerElement_Escapes()
    {
        var declaration = ParseResponseDeclaration("var items = new System.Collections.Generic.List<object> { response };");

        Assert.True(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task MemberCall_DoesNotEscape()
    {
        var declaration = ParseResponseDeclaration("_ = response.Content.ReadAsStringAsync();");

        Assert.False(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task MemberAccessAsArgument_DoesNotEscape()
    {
        var declaration = ParseResponseDeclaration("Takes(response.Content);");

        Assert.False(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task LocalReassignment_DoesNotEscape()
    {
        var declaration = ParseResponseDeclaration("response = other;");

        Assert.False(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    [Fact]
    public async Task TypeTest_DoesNotEscape()
    {
        var declaration = ParseResponseDeclaration("if (response is not null) { Takes(1); }");

        Assert.False(UsingDeclarationEscapeGate.VariableEscapesScope(declaration, "response"));
        await Task.CompletedTask;
    }

    private static LocalDeclarationStatementSyntax ParseResponseDeclaration(string tailStatement)
    {
        var root = CSharpSyntaxTree.ParseText(
            """
            using System.Net.Http;
            using System.Threading.Tasks;

            public sealed class Client
            {
                private HttpResponseMessage? pending;

                public async Task UseAsync(HttpClient client)
                {
                    var response = await client.GetAsync("https://example.com");
            """
            + "\n                    " + tailStatement + "\n                }\n            }\n").GetCompilationUnitRoot();

        return root.DescendantNodes()
            .OfType<LocalDeclarationStatementSyntax>()
            .First(declaration => declaration.Declaration.Variables.Any(variable => variable.Identifier.ValueText == "response"));
    }
}