HttpClient/test/Microsoft.Net.Http.Client.FunctionalTests/RedirectTests.cs at dev · newlysoft/HttpClient · 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
using System;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Xunit;

namespace Microsoft.Net.Http.Client.FunctionalTests
{
    public class RedirectTests
    {
        [Fact]
        public async Task RedirectWithRedirectsDisabled_ReturnsRedirectResponse()
        {
            string baseAddress;
            using (var listener = Utilities.CreateServer(out baseAddress))
            {
                var acceptTask = listener.GetContextAsync();

                using (HttpClient client = new HttpClient(new ManagedHandler() { RedirectMode = RedirectMode.None }))
                {
                    var requestTask = client.GetAsync(baseAddress);

                    var serverContext = await acceptTask;
                    serverContext.Response.Redirect("/Foo");
                    serverContext.Response.Close();

                    using (var response = await requestTask)
                    {
                        Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
                        Assert.Equal("Found", response.ReasonPhrase);
                        Assert.Equal(new Version(1, 1), response.Version);
                        Assert.True(response.Headers.Contains("Location"));
                        Assert.Equal("/Foo", response.Headers.GetValues("Location").First());
                        Assert.Equal(0, response.Content.Headers.ContentLength);
                        Assert.NotNull(response.Content);
                        Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync());
                    }
                }
            }
        }

        [Fact]
        public async Task Redirect_Redirected()
        {
            string baseAddress;
            using (var listener = Utilities.CreateServer(out baseAddress))
            {
                var acceptTask = listener.GetContextAsync();

                using (HttpClient client = new HttpClient(new ManagedHandler()))
                {
                    var requestTask = client.GetAsync(baseAddress);

                    var serverContext = await acceptTask;
                    Assert.Equal("/", serverContext.Request.Url.AbsolutePath);
                    serverContext.Response.Redirect("/Foo");
                    serverContext.Response.Close();

                    serverContext = await listener.GetContextAsync();
                    Assert.Equal("/Foo", serverContext.Request.Url.AbsolutePath);
                    serverContext.Response.Close();

                    using (var response = await requestTask)
                    {
                        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                        Assert.Equal("OK", response.ReasonPhrase);
                        Assert.Equal(new Version(1, 1), response.Version);
                        Assert.Equal(0, response.Content.Headers.ContentLength);
                        Assert.NotNull(response.Content);
                        Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync());
                    }
                }
            }
        }

        [Fact]
        public async Task RedirectLimitHit_RedirectsStop()
        {
            string baseAddress;
            using (var listener = Utilities.CreateServer(out baseAddress))
            {
                var acceptTask = listener.GetContextAsync();

                using (HttpClient client = new HttpClient(new ManagedHandler() { MaxAutomaticRedirects = 2 }))
                {
                    var requestTask = client.GetAsync(baseAddress);

                    var serverContext = await acceptTask;
                    Assert.Equal("/", serverContext.Request.Url.AbsolutePath);
                    serverContext.Response.Redirect("/1");
                    serverContext.Response.Close();

                    serverContext = await listener.GetContextAsync();
                    Assert.Equal("/1", serverContext.Request.Url.AbsolutePath);
                    serverContext.Response.Redirect("/2");
                    serverContext.Response.Close();

                    serverContext = await listener.GetContextAsync();
                    Assert.Equal("/2", serverContext.Request.Url.AbsolutePath);
                    serverContext.Response.Redirect("/3");
                    serverContext.Response.Close();

                    using (var response = await requestTask)
                    {
                        Assert.Equal(HttpStatusCode.Found, response.StatusCode);
                        Assert.Equal("Found", response.ReasonPhrase);
                        Assert.Equal(new Version(1, 1), response.Version);
                        Assert.True(response.Headers.Contains("Location"));
                        Assert.Equal("/3", response.Headers.GetValues("Location").First());
                        Assert.Equal(0, response.Content.Headers.ContentLength);
                        Assert.NotNull(response.Content);
                        Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync());
                    }
                }
            }
        }
    }
}