Skip to content

Commit 8f3c2f3

Browse files
waldekmastykarzwaldekmastykarz
authored
Merge branch 'main' into fix-hosts-to-watch
2 parents 4ec1686 + 0ce3b7c commit 8f3c2f3

20 files changed

+395
-38
lines changed

‎dev-proxy-abstractions/PluginEvents.cs‎

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -64,11 +64,8 @@ internal ProxyHttpEventArgsBase(SessionEventArgs session)
6464

6565
public SessionEventArgs Session { get; }
6666

67-
public bool HasRequestUrlMatch(ISet<UrlToWatch> watchedUrls)
68-
{
69-
var match = watchedUrls.FirstOrDefault(r => r.Url.IsMatch(Session.HttpClient.Request.RequestUri.AbsoluteUri));
70-
return match is not null && !match.Exclude;
71-
}
67+
public bool HasRequestUrlMatch(ISet<UrlToWatch> watchedUrls) =>
68+
ProxyUtils.MatchesUrlToWatch(watchedUrls, Session.HttpClient.Request.RequestUri.AbsoluteUri);
7269
}
7370

7471
public class ProxyRequestArgs(SessionEventArgs session, ResponseState responseState) : ProxyHttpEventArgsBase(session)

‎dev-proxy-abstractions/ProxyUtils.cs‎

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -352,4 +352,107 @@ public static void MergeHeaders(IList<MockResponseHeader> allHeaders, IList<Mock
352352
}
353353

354354
public static JsonSerializerOptions JsonSerializerOptions => jsonSerializerOptions;
355+
356+
public static bool MatchesUrlToWatch(ISet<UrlToWatch> watchedUrls, string url)
357+
{
358+
if (url.Contains('*'))
359+
{
360+
// url contains a wildcard, so convert it to regex and compare
361+
var match = watchedUrls.FirstOrDefault(r => {
362+
var pattern = RegexToPattern(r.Url);
363+
var result = UrlRegexComparer.CompareRegexPatterns(pattern, url);
364+
return result != UrlRegexComparisonResult.PatternsMutuallyExclusive;
365+
});
366+
return match is not null && !match.Exclude;
367+
}
368+
else
369+
{
370+
var match = watchedUrls.FirstOrDefault(r => r.Url.IsMatch(url));
371+
return match is not null && !match.Exclude;
372+
}
373+
}
374+
375+
public static string PatternToRegex(string pattern)
376+
{
377+
return $"^{Regex.Escape(pattern).Replace("\\*", ".*")}$";
378+
}
379+
380+
public static string RegexToPattern(Regex regex)
381+
{
382+
return Regex.Unescape(regex.ToString())
383+
.Trim('^', '$')
384+
.Replace(".*", "*");
385+
}
386+
387+
public static List<string> GetWildcardPatterns(List<string> urls)
388+
{
389+
return urls
390+
.GroupBy(url =>
391+
{
392+
if (url.Contains('*'))
393+
{
394+
return url;
395+
}
396+
397+
var uri = new Uri(url);
398+
return $"{uri.Scheme}://{uri.Host}";
399+
})
400+
.Select(group =>
401+
{
402+
if (group.Count() == 1)
403+
{
404+
var url = group.First();
405+
if (url.Contains('*'))
406+
{
407+
return url;
408+
}
409+
410+
// For single URLs, use the URL up to the last segment
411+
var uri = new Uri(url);
412+
var path = uri.AbsolutePath;
413+
var lastSlashIndex = path.LastIndexOf('/');
414+
return $"{group.Key}{path[..lastSlashIndex]}/*";
415+
}
416+
417+
// For multiple URLs, find the common prefix
418+
var paths = group.Select(url => {
419+
if (url.Contains('*'))
420+
{
421+
return url;
422+
}
423+
424+
return new Uri(url).AbsolutePath;
425+
}).ToList();
426+
var commonPrefix = GetCommonPrefix(paths);
427+
return $"{group.Key}{commonPrefix}*";
428+
})
429+
.OrderBy(x => x)
430+
.ToList();
431+
}
432+
433+
private static string GetCommonPrefix(List<string> paths)
434+
{
435+
if (paths.Count == 0) return string.Empty;
436+
437+
var firstPath = paths[0];
438+
var commonPrefixLength = firstPath.Length;
439+
440+
for (var i = 1; i < paths.Count; i++)
441+
{
442+
commonPrefixLength = Math.Min(commonPrefixLength, paths[i].Length);
443+
for (var j = 0; j < commonPrefixLength; j++)
444+
{
445+
if (firstPath[j] != paths[i][j])
446+
{
447+
commonPrefixLength = j;
448+
break;
449+
}
450+
}
451+
}
452+
453+
// Find the last complete path segment
454+
var prefix = firstPath[..commonPrefixLength];
455+
var lastSlashIndex = prefix.LastIndexOf('/');
456+
return lastSlashIndex >= 0 ? prefix[..(lastSlashIndex + 1)] : prefix;
457+
}
355458
}

‎dev-proxy-abstractions/UrlRegexComparer.cs‎

Lines changed: 143 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,143 @@
1+
// Licensed to the .NET Foundation under one or more agreements.
2+
// The .NET Foundation licenses this file to you under the MIT license.
3+
// See the LICENSE file in the project root for more information.
4+
5+
using System.Text.RegularExpressions;
6+
7+
namespace DevProxy.Abstractions;
8+
9+
enum UrlRegexComparisonResult
10+
{
11+
/// <summary>
12+
/// The first pattern is broader than the second pattern.
13+
/// </summary>
14+
FirstPatternBroader,
15+
16+
/// <summary>
17+
/// The second pattern is broader than the first pattern.
18+
/// </summary>
19+
SecondPatternBroader,
20+
21+
/// <summary>
22+
/// The patterns are equivalent.
23+
/// </summary>
24+
PatternsEquivalent,
25+
26+
/// <summary>
27+
/// The patterns are mutually exclusive.
28+
/// </summary>
29+
PatternsMutuallyExclusive
30+
}
31+
32+
class UrlRegexComparer
33+
{
34+
/// <summary>
35+
/// Compares two URL patterns and returns a value indicating their
36+
// relationship.
37+
/// </summary>
38+
/// <param name="pattern1">First URL pattern</param>
39+
/// <param name="pattern2">Second URL pattern</param>
40+
/// <returns>1 when the first pattern is broader; -1 when the second pattern
41+
/// is broader or patterns are mutually exclusive; 0 when the patterns are
42+
/// equal</returns>
43+
public static UrlRegexComparisonResult CompareRegexPatterns(string pattern1, string pattern2)
44+
{
45+
var regex1 = new Regex(ProxyUtils.PatternToRegex(pattern1));
46+
var regex2 = new Regex(ProxyUtils.PatternToRegex(pattern2));
47+
48+
// Generate test URLs based on patterns
49+
var testUrls = GenerateTestUrls(pattern1, pattern2);
50+
51+
var matches1 = testUrls.Where(url => regex1.IsMatch(url)).ToList();
52+
var matches2 = testUrls.Where(url => regex2.IsMatch(url)).ToList();
53+
54+
bool pattern1MatchesAll = matches2.All(regex1.IsMatch);
55+
bool pattern2MatchesAll = matches1.All(regex2.IsMatch);
56+
57+
if (pattern1MatchesAll && !pattern2MatchesAll)
58+
// Pattern 1 is broader
59+
return UrlRegexComparisonResult.FirstPatternBroader;
60+
else if (pattern2MatchesAll && !pattern1MatchesAll)
61+
// Pattern 2 is broader
62+
return UrlRegexComparisonResult.SecondPatternBroader;
63+
else if (pattern1MatchesAll && pattern2MatchesAll)
64+
// Patterns are equivalent
65+
return UrlRegexComparisonResult.PatternsEquivalent;
66+
else
67+
// Patterns have different matching sets
68+
return UrlRegexComparisonResult.PatternsMutuallyExclusive;
69+
}
70+
71+
private static List<string> GenerateTestUrls(string pattern1, string pattern2)
72+
{
73+
var urls = new HashSet<string>();
74+
75+
// Extract domains and paths from patterns
76+
var domains = ExtractDomains(pattern1)
77+
.Concat(ExtractDomains(pattern2))
78+
.Distinct()
79+
.ToList();
80+
81+
var paths = ExtractPaths(pattern1)
82+
.Concat(ExtractPaths(pattern2))
83+
.Distinct()
84+
.ToList();
85+
86+
// Generate combinations
87+
foreach (var domain in domains)
88+
{
89+
foreach (var path in paths)
90+
{
91+
urls.Add($"https://{domain}/{path}");
92+
}
93+
94+
// Add variants
95+
urls.Add($"https://{domain}/");
96+
urls.Add($"https://sub.{domain}/path");
97+
urls.Add($"https://other-{domain}/different");
98+
}
99+
100+
return urls.ToList();
101+
}
102+
103+
private static HashSet<string> ExtractDomains(string pattern)
104+
{
105+
var domains = new HashSet<string>();
106+
107+
// Extract literal domains
108+
var domainMatch = Regex.Match(Regex.Unescape(pattern), @"https://([^/\s]+)");
109+
if (domainMatch.Success)
110+
{
111+
var domain = domainMatch.Groups[1].Value;
112+
if (!domain.Contains(".*"))
113+
domains.Add(domain);
114+
}
115+
116+
// Add test domains
117+
domains.Add("example.com");
118+
domains.Add("test.com");
119+
120+
return domains;
121+
}
122+
123+
private static HashSet<string> ExtractPaths(string pattern)
124+
{
125+
var paths = new HashSet<string>();
126+
127+
// Extract literal paths
128+
var pathMatch = Regex.Match(pattern, @"https://[^/]+(/[^/\s]+)");
129+
if (pathMatch.Success)
130+
{
131+
var path = pathMatch.Groups[1].Value;
132+
if (!path.Contains(".*"))
133+
paths.Add(path.TrimStart('/'));
134+
}
135+
136+
// Add test paths
137+
paths.Add("api");
138+
paths.Add("users");
139+
paths.Add("path1/path2");
140+
141+
return paths;
142+
}
143+
}

‎dev-proxy-abstractions/dev-proxy-abstractions.csproj‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
<RootNamespace>DevProxy.Abstractions</RootNamespace>
66
<ImplicitUsings>enable</ImplicitUsings>
77
<Nullable>enable</Nullable>
8-
<Version>0.25.0</Version>
8+
<Version>0.26.0</Version>
99
<IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
1010
<RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
1111
</PropertyGroup>

‎dev-proxy-plugins/Mocks/CrudApiPlugin.cs‎

Lines changed: 13 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -87,8 +87,6 @@ public override async Task RegisterAsync()
8787

8888
ConfigSection?.Bind(_configuration);
8989

90-
PluginEvents.BeforeRequest += OnRequestAsync;
91-
9290
_proxyConfiguration = Context.Configuration;
9391

9492
_configuration.ApiFile = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.ApiFile), Path.GetDirectoryName(_proxyConfiguration?.ConfigFile ?? string.Empty) ?? string.Empty);
@@ -103,8 +101,21 @@ public override async Task RegisterAsync()
103101
_configuration.Auth = CrudApiAuthType.None;
104102
}
105103

104+
if (!ProxyUtils.MatchesUrlToWatch(UrlsToWatch, _configuration.BaseUrl))
105+
{
106+
Logger.LogWarning(
107+
"The base URL of the API {baseUrl} does not match any URL to watch. The {plugin} plugin will be disabled. To enable it, add {url}* to the list of URLs to watch and restart Dev Proxy.",
108+
_configuration.BaseUrl,
109+
Name,
110+
_configuration.BaseUrl
111+
);
112+
return;
113+
}
114+
106115
LoadData();
107116
await SetupOpenIdConnectConfigurationAsync();
117+
118+
PluginEvents.BeforeRequest += OnRequestAsync;
108119
}
109120

110121
private async Task SetupOpenIdConnectConfigurationAsync()

‎dev-proxy-plugins/Mocks/MockResponsePlugin.cs‎

Lines changed: 58 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ public class MockResponseConfiguration
2828
public bool BlockUnmockedRequests { get; set; } = false;
2929

3030
[JsonPropertyName("$schema")]
31-
public string Schema { get; set; } = "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v0.25.0/mockresponseplugin.mocksfile.schema.json";
31+
public string Schema { get; set; } = "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v0.26.0/mockresponseplugin.mocksfile.schema.json";
3232
public IEnumerable<MockResponse> Mocks { get; set; } = [];
3333
}
3434

@@ -100,6 +100,61 @@ private void OnOptionsLoaded(object? sender, OptionsLoadedArgs e)
100100

101101
// load the responses from the configured mocks file
102102
_loader?.InitResponsesWatcher();
103+
104+
ValidateMocks();
105+
}
106+
107+
private void ValidateMocks()
108+
{
109+
Logger.LogDebug("Validating mock responses");
110+
111+
if (_configuration.NoMocks)
112+
{
113+
Logger.LogDebug("Mocks are disabled");
114+
return;
115+
}
116+
117+
if (_configuration.Mocks is null ||
118+
!_configuration.Mocks.Any())
119+
{
120+
Logger.LogDebug("No mock responses defined");
121+
return;
122+
}
123+
124+
var unmatchedMockUrls = new List<string>();
125+
126+
foreach (var mock in _configuration.Mocks)
127+
{
128+
if (mock.Request is null)
129+
{
130+
Logger.LogDebug("Mock response is missing a request");
131+
continue;
132+
}
133+
134+
if (string.IsNullOrEmpty(mock.Request.Url))
135+
{
136+
Logger.LogDebug("Mock response is missing a URL");
137+
continue;
138+
}
139+
140+
if (!ProxyUtils.MatchesUrlToWatch(UrlsToWatch, mock.Request.Url))
141+
{
142+
unmatchedMockUrls.Add(mock.Request.Url);
143+
}
144+
}
145+
146+
if (unmatchedMockUrls.Count == 0)
147+
{
148+
return;
149+
}
150+
151+
var suggestedWildcards = ProxyUtils.GetWildcardPatterns(unmatchedMockUrls);
152+
Logger.LogWarning(
153+
"The following URLs in {mocksFile} don't match any URL to watch: {unmatchedMocks}. Add the following URLs to URLs to watch: {urlsToWatch}",
154+
_configuration.MocksFile,
155+
string.Join(", ", unmatchedMockUrls),
156+
string.Join(", ", suggestedWildcards)
157+
);
103158
}
104159

105160
protected virtual Task OnRequestAsync(object? sender, ProxyRequestArgs e)
@@ -180,9 +235,8 @@ _configuration.Mocks is null ||
180235
return false;
181236
}
182237

183-
//turn mock URL with wildcard into a regex and match against the request URL
184-
var mockResponseUrlRegex = Regex.Escape(mockResponse.Request.Url).Replace("\\*", ".*");
185-
return Regex.IsMatch(request.Url, $"^{mockResponseUrlRegex}$") &&
238+
// turn mock URL with wildcard into a regex and match against the request URL
239+
return Regex.IsMatch(request.Url, ProxyUtils.PatternToRegex(mockResponse.Request.Url)) &&
186240
HasMatchingBody(mockResponse, request) &&
187241
IsNthRequest(mockResponse);
188242
});

0 commit comments

Comments
 (0)