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
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Castle.Core.Internal;
using Microsoft.AspNetCore.Http;
namespace Microsoft.AspNetCore.OutputCaching.Tests;
public class OutputCacheAttributeTests
{
[Fact]
public void Attribute_CreatesDefaultPolicy()
{
var context = TestUtils.CreateUninitializedContext();
var attribute = OutputCacheMethods.GetAttribute(nameof(OutputCacheMethods.Default));
var policy = attribute.BuildPolicy();
Assert.Equal(DefaultPolicy.Instance, policy);
}
[Fact]
public async Task Attribute_CreatesExpirePolicy()
{
var context = TestUtils.CreateUninitializedContext();
var attribute = OutputCacheMethods.GetAttribute(nameof(OutputCacheMethods.Duration));
await attribute.BuildPolicy().CacheRequestAsync(context, cancellation: default);
Assert.True(context.EnableOutputCaching);
Assert.Equal(42, context.ResponseExpirationTimeSpan?.TotalSeconds);
}
[Fact]
public async Task Attribute_CreatesNoStorePolicy()
{
var context = TestUtils.CreateUninitializedContext();
var attribute = OutputCacheMethods.GetAttribute(nameof(OutputCacheMethods.NoStore));
await attribute.BuildPolicy().CacheRequestAsync(context, cancellation: default);
Assert.False(context.EnableOutputCaching);
}
[Fact]
public async Task Attribute_CreatesNamedPolicy()
{
var options = new OutputCacheOptions();
options.AddPolicy("MyPolicy", b => b.Expire(TimeSpan.FromSeconds(42)));
var context = TestUtils.CreateTestContext(options: options);
var attribute = OutputCacheMethods.GetAttribute(nameof(OutputCacheMethods.PolicyName));
await attribute.BuildPolicy().CacheRequestAsync(context, cancellation: default);
Assert.True(context.EnableOutputCaching);
Assert.Equal(42, context.ResponseExpirationTimeSpan?.TotalSeconds);
}
[Fact]
public async Task Attribute_CreatesVaryByHeaderPolicy()
{
var context = TestUtils.CreateUninitializedContext();
context.HttpContext.Request.Headers["HeaderA"] = "ValueA";
context.HttpContext.Request.Headers["HeaderB"] = "ValueB";
var attribute = OutputCacheMethods.GetAttribute(nameof(OutputCacheMethods.VaryByHeaderNames));
await attribute.BuildPolicy().CacheRequestAsync(context, cancellation: default);
Assert.True(context.EnableOutputCaching);
Assert.Contains("HeaderA", (IEnumerable<string>)context.CacheVaryByRules.HeaderNames);
Assert.Contains("HeaderC", (IEnumerable<string>)context.CacheVaryByRules.HeaderNames);
Assert.DoesNotContain("HeaderB", (IEnumerable<string>)context.CacheVaryByRules.HeaderNames);
}
[Fact]
public async Task Attribute_CreatesVaryByQueryPolicy()
{
var context = TestUtils.CreateUninitializedContext();
context.HttpContext.Request.QueryString = new QueryString("?QueryA=ValueA&QueryB=ValueB");
var attribute = OutputCacheMethods.GetAttribute(nameof(OutputCacheMethods.VaryByQueryKeys));
await attribute.BuildPolicy().CacheRequestAsync(context, cancellation: default);
Assert.True(context.EnableOutputCaching);
Assert.Contains("QueryA", (IEnumerable<string>)context.CacheVaryByRules.QueryKeys);
Assert.Contains("QueryC", (IEnumerable<string>)context.CacheVaryByRules.QueryKeys);
Assert.DoesNotContain("QueryB", (IEnumerable<string>)context.CacheVaryByRules.QueryKeys);
}
[Fact]
public async Task Attribute_CreatesVaryByRoutePolicy()
{
var context = TestUtils.CreateUninitializedContext();
context.HttpContext.Request.RouteValues = new Routing.RouteValueDictionary()
{
["RouteA"] = "ValueA",
["RouteB"] = 123.456,
};
var attribute = OutputCacheMethods.GetAttribute(nameof(OutputCacheMethods.VaryByRouteValueNames));
await attribute.BuildPolicy().CacheRequestAsync(context, cancellation: default);
Assert.True(context.EnableOutputCaching);
Assert.Contains("RouteA", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames);
Assert.Contains("RouteC", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames);
Assert.DoesNotContain("RouteB", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames);
}
private class OutputCacheMethods
{
public static OutputCacheAttribute GetAttribute(string methodName)
{
return typeof(OutputCacheMethods).GetMethod(methodName, System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public).GetAttribute<OutputCacheAttribute>();
}
[OutputCache()]
public static void Default() { }
[OutputCache(Duration = 42)]
public static void Duration() { }
[OutputCache(NoStore = true)]
public static void NoStore() { }
[OutputCache(PolicyName = "MyPolicy")]
public static void PolicyName() { }
[OutputCache(VaryByHeaderNames = new[] { "HeaderA", "HeaderC" })]
public static void VaryByHeaderNames() { }
[OutputCache(VaryByQueryKeys = new[] { "QueryA", "QueryC" })]
public static void VaryByQueryKeys() { }
[OutputCache(VaryByRouteValueNames = new[] { "RouteA", "RouteC" })]
public static void VaryByRouteValueNames() { }
}
}
|
