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
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Reflection;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http.Metadata;
using Microsoft.AspNetCore.Routing;
using Microsoft.AspNetCore.Routing.Patterns;
using Microsoft.AspNetCore.Testing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
namespace Microsoft.AspNetCore.Http.HttpResults;
public partial class CreatedAtRouteResultTests
{
public static IEnumerable<object[]> CreatedAtRouteData
{
get
{
yield return new object[] { null };
yield return
new object[] {
new Dictionary<string, string>() { { "hello", "world" } }
};
yield return
new object[] {
new RouteValueDictionary(new Dictionary<string, string>() {
{ "test", "case" },
{ "sample", "route" }
})
};
}
}
[Theory]
[MemberData(nameof(CreatedAtRouteData))]
public async Task CreatedAtRouteResult_ReturnsStatusCode_SetsLocationHeader(object values)
{
// Arrange
var expectedUrl = "testAction";
var httpContext = GetHttpContext(expectedUrl);
// Act
var result = new CreatedAtRoute(routeName: null, routeValues: values);
await result.ExecuteAsync(httpContext);
// Assert
Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode);
Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);
}
[Fact]
public async Task CreatedAtRouteResult_ThrowsOnNullUrl()
{
// Arrange
var httpContext = GetHttpContext(expectedUrl: null);
var result = new CreatedAtRoute(
routeName: null,
routeValues: new Dictionary<string, object>());
// Act & Assert
await ExceptionAssert.ThrowsAsync<InvalidOperationException>(
async () => await result.ExecuteAsync(httpContext),
"No route matches the supplied values.");
}
[Fact]
public void PopulateMetadata_AddsResponseTypeMetadata()
{
// Arrange
CreatedAtRoute MyApi() { throw new NotImplementedException(); }
var metadata = new List<object>();
var builder = new RouteEndpointBuilder(requestDelegate: null, RoutePatternFactory.Parse("/"), order: 0);
// Act
PopulateMetadata<CreatedAtRoute>(((Delegate)MyApi).GetMethodInfo(), builder);
// Assert
var producesResponseTypeMetadata = builder.Metadata.OfType<ProducesResponseTypeMetadata>().Last();
Assert.Equal(StatusCodes.Status201Created, producesResponseTypeMetadata.StatusCode);
Assert.Equal(typeof(void), producesResponseTypeMetadata.Type);
}
[Fact]
public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
{
// Arrange
var result = new CreatedAtRoute(null);
HttpContext httpContext = null;
// Act & Assert
Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
}
[Fact]
public void PopulateMetadata_ThrowsArgumentNullException_WhenMethodOrBuilderAreNull()
{
// Act & Assert
Assert.Throws<ArgumentNullException>("method", () => PopulateMetadata<CreatedAtRoute>(null, new RouteEndpointBuilder(requestDelegate: null, RoutePatternFactory.Parse("/"), order: 0)));
Assert.Throws<ArgumentNullException>("builder", () => PopulateMetadata<CreatedAtRoute>(((Delegate)PopulateMetadata_ThrowsArgumentNullException_WhenMethodOrBuilderAreNull).GetMethodInfo(), null));
}
[Fact]
public void CreatedAtRouteResult_Implements_IValueHttpResult_Correctly()
{
// Arrange & Act
var rawResult = new CreatedAtRoute(
routeName: null,
routeValues: new Dictionary<string, object>());
// Assert
var result = Assert.IsAssignableFrom<IStatusCodeHttpResult>(rawResult);
Assert.Equal(StatusCodes.Status201Created, result.StatusCode);
}
private static void PopulateMetadata<TResult>(MethodInfo method, EndpointBuilder builder)
where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(method, builder);
private static HttpContext GetHttpContext(string expectedUrl)
{
var httpContext = new DefaultHttpContext();
httpContext.Request.PathBase = new PathString("");
httpContext.Response.Body = new MemoryStream();
httpContext.RequestServices = CreateServices(expectedUrl);
return httpContext;
}
private static IServiceProvider CreateServices(string expectedUrl)
{
var services = new ServiceCollection();
services.AddSingleton<ILoggerFactory, NullLoggerFactory>();
services.AddSingleton<LinkGenerator>(new TestLinkGenerator
{
Url = expectedUrl
});
return services.BuildServiceProvider();
}
}
|
