add port fixture to fix tests on windows

phnx47 · phnx47 · commit 4d468eaa3c48 · 2024-12-18T23:08:22.000+07:00
diff --git a/tests/MetricServerTests.cs b/tests/MetricServerTests.cs
@@ -9,21 +9,13 @@
 
 namespace Prometheus.Client.MetricServer.Tests;
 
-public class MetricServerTests
+public class MetricServerTests(PortFixture fixture, ITestOutputHelper testOutputHelper) : IClassFixture<PortFixture>
 {
-    private IMetricServer _metricServer;
-    private readonly ITestOutputHelper _testOutputHelper;
-    private const int _port = 9091;
-
-    public MetricServerTests(ITestOutputHelper testOutputHelper)
+    private MetricServer _metricServer = new(new MetricServerOptions
     {
-        _testOutputHelper = testOutputHelper;
-        _metricServer = new MetricServer(new MetricServerOptions
-        {
-            Port = _port,
-            CollectorRegistryInstance = new CollectorRegistry()
-        });
-    }
+        Port = fixture.Port,
+        CollectorRegistryInstance = new CollectorRegistry()
+    });
 
     [Fact]
     public void Null_Options_Throws_ArgumentNullException()
@@ -91,14 +83,14 @@ public async Task BaseMapPath_FindMetrics()
             var counter = Metrics.DefaultFactory.CreateCounter("test_counter", "help");
             counter.Inc();
             using var httpClient = new HttpClient();
-            string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");
+            string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");
             Assert.False(string.IsNullOrEmpty(response));
             Assert.Contains("process_private_memory_bytes", response);
             Assert.Contains("dotnet_total_memory_bytes", response);
         }
         catch (Exception ex)
         {
-            _testOutputHelper.WriteLine(ex.ToString());
+            testOutputHelper.WriteLine(ex.ToString());
             throw;
         }
         finally
@@ -110,21 +102,21 @@ public async Task BaseMapPath_FindMetrics()
     [Fact]
     public async Task SetMapPath_FindMetricsWithEndSlash()
     {
-        _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = new CollectorRegistry(), MapPath = "/test" });
+        _metricServer = new MetricServer(new MetricServerOptions { Port = fixture.Port, CollectorRegistryInstance = new CollectorRegistry(), MapPath = "/test" });
         try
         {
             _metricServer.Start();
             var counter = Metrics.DefaultFactory.CreateCounter("test_counter", "help");
             counter.Inc();
             using var httpClient = new HttpClient();
-            string response = await httpClient.GetStringAsync($"http://localhost:{_port}/test/");
+            string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}/test/");
             Assert.False(string.IsNullOrEmpty(response));
             Assert.Contains("process_private_memory_bytes", response);
             Assert.Contains("dotnet_total_memory_bytes", response);
         }
         catch (Exception ex)
         {
-            _testOutputHelper.WriteLine(ex.ToString());
+            testOutputHelper.WriteLine(ex.ToString());
             throw;
         }
         finally
@@ -140,21 +132,21 @@ public async Task SetMapPath_FindMetricsWithEndSlash()
     [InlineData("/metrics965")]
     public async Task SetMapPath_FindMetrics(string mapPath)
     {
-        _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = new CollectorRegistry(), MapPath = mapPath });
+        _metricServer = new MetricServer(new MetricServerOptions { Port = fixture.Port, CollectorRegistryInstance = new CollectorRegistry(), MapPath = mapPath });
         try
         {
             _metricServer.Start();
             using var httpClient = new HttpClient();
             if (!mapPath.StartsWith("/"))
                 mapPath = "/" + mapPath;
-            string response = await httpClient.GetStringAsync($"http://localhost:{_port}" + mapPath);
+            string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}" + mapPath);
             Assert.False(string.IsNullOrEmpty(response));
             Assert.Contains("process_private_memory_bytes", response);
             Assert.Contains("dotnet_total_memory_bytes", response);
         }
         catch (Exception ex)
         {
-            _testOutputHelper.WriteLine(ex.ToString());
+            testOutputHelper.WriteLine(ex.ToString());
             throw;
         }
         finally
@@ -168,7 +160,7 @@ public async Task CustomCounter_FindMetric()
     {
         var registry = new CollectorRegistry();
         var factory = new MetricFactory(registry);
-        _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = registry });
+        _metricServer = new MetricServer(new MetricServerOptions { Port = fixture.Port, CollectorRegistryInstance = registry });
 
         try
         {
@@ -179,12 +171,12 @@ public async Task CustomCounter_FindMetric()
             counter.Inc();
 
             using var httpClient = new HttpClient();
-            string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");
+            string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");
             Assert.Contains(metricName, response);
         }
         catch (Exception ex)
         {
-            _testOutputHelper.WriteLine(ex.ToString());
+            testOutputHelper.WriteLine(ex.ToString());
             throw;
         }
         finally
@@ -200,15 +192,15 @@ public async Task AddLegacyMetrics_False_FindMetrics()
         {
             _metricServer.Start();
             using var httpClient = new HttpClient();
-            string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");
+            string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");
             Assert.Contains("process_private_memory_bytes", response);
             Assert.Contains("dotnet_total_memory_bytes", response);
             Assert.DoesNotContain("process_private_bytes", response);
             Assert.DoesNotContain("dotnet_totalmemory", response);
         }
         catch (Exception ex)
         {
-            _testOutputHelper.WriteLine(ex.ToString());
+            testOutputHelper.WriteLine(ex.ToString());
             throw;
         }
         finally
@@ -220,21 +212,22 @@ public async Task AddLegacyMetrics_False_FindMetrics()
     [Fact]
     public async Task AddLegacyMetrics_True_FindMetrics()
     {
-        _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = new CollectorRegistry(), AddLegacyMetrics = true });
+        _metricServer = new MetricServer(new MetricServerOptions
+            { Port = fixture.Port, CollectorRegistryInstance = new CollectorRegistry(), AddLegacyMetrics = true });
 
         try
         {
             _metricServer.Start();
             using var httpClient = new HttpClient();
-            string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");
+            string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");
             Assert.Contains("process_private_memory_bytes", response);
             Assert.Contains("dotnet_total_memory_bytes", response);
             Assert.Contains("process_private_bytes", response);
             Assert.Contains("dotnet_totalmemory", response);
         }
         catch (Exception ex)
         {
-            _testOutputHelper.WriteLine(ex.ToString());
+            testOutputHelper.WriteLine(ex.ToString());
             throw;
         }
         finally
@@ -253,12 +246,12 @@ public async Task WrongUrl_NotFound()
             counter.Inc();
             using var httpClient = new HttpClient();
 
-            var response = await httpClient.GetAsync($"http://localhost:{_port}/not-found");
+            var response = await httpClient.GetAsync($"http://localhost:{fixture.Port}/not-found");
             Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
         }
         catch (Exception ex)
         {
-            _testOutputHelper.WriteLine(ex.ToString());
+            testOutputHelper.WriteLine(ex.ToString());
             throw;
         }
         finally
@@ -272,7 +265,7 @@ public async Task CustormEncoding_FindHelp()
     {
         var registry = new CollectorRegistry();
         var factory = new MetricFactory(registry);
-        _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = registry, ResponseEncoding = Encoding.UTF8 });
+        _metricServer = new MetricServer(new MetricServerOptions { Port = fixture.Port, CollectorRegistryInstance = registry, ResponseEncoding = Encoding.UTF8 });
 
         try
         {
@@ -283,12 +276,12 @@ public async Task CustormEncoding_FindHelp()
             counter.Inc();
 
             using var httpClient = new HttpClient();
-            string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");
+            string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");
             Assert.Contains(help, response);
         }
         catch (Exception ex)
         {
-            _testOutputHelper.WriteLine(ex.ToString());
+            testOutputHelper.WriteLine(ex.ToString());
             throw;
         }
         finally
diff --git a/tests/PortFixture.cs b/tests/PortFixture.cs
@@ -0,0 +1,25 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace Prometheus.Client.MetricServer.Tests;
+
+public class PortFixture
+{
+    public int Port { get; } = FindAvailablePort();
+
+    private static int FindAvailablePort()
+    {
+        var listener = new TcpListener(IPAddress.Loopback, 0);
+
+        try
+        {
+            listener.Start();
+            int port = ((IPEndPoint)listener.LocalEndpoint).Port;
+            return port;
+        }
+        finally
+        {
+            listener.Stop();
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -9,21 +9,13 @@`
`9`	`9`
`10`	`10`	`namespace Prometheus.Client.MetricServer.Tests;`
`11`	`11`
`12`		`-public class MetricServerTests`
	`12`	`+public class MetricServerTests(PortFixture fixture, ITestOutputHelper testOutputHelper) : IClassFixture<PortFixture>`
`13`	`13`	`{`
`14`		`- private IMetricServer _metricServer;`
`15`		`- private readonly ITestOutputHelper _testOutputHelper;`
`16`		`- private const int _port = 9091;`
`17`		`-`
`18`		`- public MetricServerTests(ITestOutputHelper testOutputHelper)`
	`14`	`+ private MetricServer _metricServer = new(new MetricServerOptions`
`19`	`15`	`{`
`20`		`- _testOutputHelper = testOutputHelper;`
`21`		`- _metricServer = new MetricServer(new MetricServerOptions`
`22`		`- {`
`23`		`- Port = _port,`
`24`		`- CollectorRegistryInstance = new CollectorRegistry()`
`25`		`- });`
`26`		`- }`
	`16`	`+ Port = fixture.Port,`
	`17`	`+ CollectorRegistryInstance = new CollectorRegistry()`
	`18`	`+ });`
`27`	`19`
`28`	`20`	`[Fact]`
`29`	`21`	`public void Null_Options_Throws_ArgumentNullException()`
`@@ -91,14 +83,14 @@ public async Task BaseMapPath_FindMetrics()`
`91`	`83`	`var counter = Metrics.DefaultFactory.CreateCounter("test_counter", "help");`
`92`	`84`	`counter.Inc();`
`93`	`85`	`using var httpClient = new HttpClient();`
`94`		`- string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");`
	`86`	`+ string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");`
`95`	`87`	`Assert.False(string.IsNullOrEmpty(response));`
`96`	`88`	`Assert.Contains("process_private_memory_bytes", response);`
`97`	`89`	`Assert.Contains("dotnet_total_memory_bytes", response);`
`98`	`90`	`}`
`99`	`91`	`catch (Exception ex)`
`100`	`92`	`{`
`101`		`- _testOutputHelper.WriteLine(ex.ToString());`
	`93`	`+ testOutputHelper.WriteLine(ex.ToString());`
`102`	`94`	`throw;`
`103`	`95`	`}`
`104`	`96`	`finally`
`@@ -110,21 +102,21 @@ public async Task BaseMapPath_FindMetrics()`
`110`	`102`	`[Fact]`
`111`	`103`	`public async Task SetMapPath_FindMetricsWithEndSlash()`
`112`	`104`	`{`
`113`		`- _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = new CollectorRegistry(), MapPath = "/test" });`
	`105`	`+ _metricServer = new MetricServer(new MetricServerOptions { Port = fixture.Port, CollectorRegistryInstance = new CollectorRegistry(), MapPath = "/test" });`
`114`	`106`	`try`
`115`	`107`	`{`
`116`	`108`	`_metricServer.Start();`
`117`	`109`	`var counter = Metrics.DefaultFactory.CreateCounter("test_counter", "help");`
`118`	`110`	`counter.Inc();`
`119`	`111`	`using var httpClient = new HttpClient();`
`120`		`- string response = await httpClient.GetStringAsync($"http://localhost:{_port}/test/");`
	`112`	`+ string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}/test/");`
`121`	`113`	`Assert.False(string.IsNullOrEmpty(response));`
`122`	`114`	`Assert.Contains("process_private_memory_bytes", response);`
`123`	`115`	`Assert.Contains("dotnet_total_memory_bytes", response);`
`124`	`116`	`}`
`125`	`117`	`catch (Exception ex)`
`126`	`118`	`{`
`127`		`- _testOutputHelper.WriteLine(ex.ToString());`
	`119`	`+ testOutputHelper.WriteLine(ex.ToString());`
`128`	`120`	`throw;`
`129`	`121`	`}`
`130`	`122`	`finally`
`@@ -140,21 +132,21 @@ public async Task SetMapPath_FindMetricsWithEndSlash()`
`140`	`132`	`[InlineData("/metrics965")]`
`141`	`133`	`public async Task SetMapPath_FindMetrics(string mapPath)`
`142`	`134`	`{`
`143`		`- _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = new CollectorRegistry(), MapPath = mapPath });`
	`135`	`+ _metricServer = new MetricServer(new MetricServerOptions { Port = fixture.Port, CollectorRegistryInstance = new CollectorRegistry(), MapPath = mapPath });`
`144`	`136`	`try`
`145`	`137`	`{`
`146`	`138`	`_metricServer.Start();`
`147`	`139`	`using var httpClient = new HttpClient();`
`148`	`140`	`if (!mapPath.StartsWith("/"))`
`149`	`141`	`mapPath = "/" + mapPath;`
`150`		`- string response = await httpClient.GetStringAsync($"http://localhost:{_port}" + mapPath);`
	`142`	`+ string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}" + mapPath);`
`151`	`143`	`Assert.False(string.IsNullOrEmpty(response));`
`152`	`144`	`Assert.Contains("process_private_memory_bytes", response);`
`153`	`145`	`Assert.Contains("dotnet_total_memory_bytes", response);`
`154`	`146`	`}`
`155`	`147`	`catch (Exception ex)`
`156`	`148`	`{`
`157`		`- _testOutputHelper.WriteLine(ex.ToString());`
	`149`	`+ testOutputHelper.WriteLine(ex.ToString());`
`158`	`150`	`throw;`
`159`	`151`	`}`
`160`	`152`	`finally`
`@@ -168,7 +160,7 @@ public async Task CustomCounter_FindMetric()`
`168`	`160`	`{`
`169`	`161`	`var registry = new CollectorRegistry();`
`170`	`162`	`var factory = new MetricFactory(registry);`
`171`		`- _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = registry });`
	`163`	`+ _metricServer = new MetricServer(new MetricServerOptions { Port = fixture.Port, CollectorRegistryInstance = registry });`
`172`	`164`
`173`	`165`	`try`
`174`	`166`	`{`
`@@ -179,12 +171,12 @@ public async Task CustomCounter_FindMetric()`
`179`	`171`	`counter.Inc();`
`180`	`172`
`181`	`173`	`using var httpClient = new HttpClient();`
`182`		`- string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");`
	`174`	`+ string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");`
`183`	`175`	`Assert.Contains(metricName, response);`
`184`	`176`	`}`
`185`	`177`	`catch (Exception ex)`
`186`	`178`	`{`
`187`		`- _testOutputHelper.WriteLine(ex.ToString());`
	`179`	`+ testOutputHelper.WriteLine(ex.ToString());`
`188`	`180`	`throw;`
`189`	`181`	`}`
`190`	`182`	`finally`
`@@ -200,15 +192,15 @@ public async Task AddLegacyMetrics_False_FindMetrics()`
`200`	`192`	`{`
`201`	`193`	`_metricServer.Start();`
`202`	`194`	`using var httpClient = new HttpClient();`
`203`		`- string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");`
	`195`	`+ string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");`
`204`	`196`	`Assert.Contains("process_private_memory_bytes", response);`
`205`	`197`	`Assert.Contains("dotnet_total_memory_bytes", response);`
`206`	`198`	`Assert.DoesNotContain("process_private_bytes", response);`
`207`	`199`	`Assert.DoesNotContain("dotnet_totalmemory", response);`
`208`	`200`	`}`
`209`	`201`	`catch (Exception ex)`
`210`	`202`	`{`
`211`		`- _testOutputHelper.WriteLine(ex.ToString());`
	`203`	`+ testOutputHelper.WriteLine(ex.ToString());`
`212`	`204`	`throw;`
`213`	`205`	`}`
`214`	`206`	`finally`
`@@ -220,21 +212,22 @@ public async Task AddLegacyMetrics_False_FindMetrics()`
`220`	`212`	`[Fact]`
`221`	`213`	`public async Task AddLegacyMetrics_True_FindMetrics()`
`222`	`214`	`{`
`223`		`- _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = new CollectorRegistry(), AddLegacyMetrics = true });`
	`215`	`+ _metricServer = new MetricServer(new MetricServerOptions`
	`216`	`+ { Port = fixture.Port, CollectorRegistryInstance = new CollectorRegistry(), AddLegacyMetrics = true });`
`224`	`217`
`225`	`218`	`try`
`226`	`219`	`{`
`227`	`220`	`_metricServer.Start();`
`228`	`221`	`using var httpClient = new HttpClient();`
`229`		`- string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");`
	`222`	`+ string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");`
`230`	`223`	`Assert.Contains("process_private_memory_bytes", response);`
`231`	`224`	`Assert.Contains("dotnet_total_memory_bytes", response);`
`232`	`225`	`Assert.Contains("process_private_bytes", response);`
`233`	`226`	`Assert.Contains("dotnet_totalmemory", response);`
`234`	`227`	`}`
`235`	`228`	`catch (Exception ex)`
`236`	`229`	`{`
`237`		`- _testOutputHelper.WriteLine(ex.ToString());`
	`230`	`+ testOutputHelper.WriteLine(ex.ToString());`
`238`	`231`	`throw;`
`239`	`232`	`}`
`240`	`233`	`finally`
`@@ -253,12 +246,12 @@ public async Task WrongUrl_NotFound()`
`253`	`246`	`counter.Inc();`
`254`	`247`	`using var httpClient = new HttpClient();`
`255`	`248`
`256`		`- var response = await httpClient.GetAsync($"http://localhost:{_port}/not-found");`
	`249`	`+ var response = await httpClient.GetAsync($"http://localhost:{fixture.Port}/not-found");`
`257`	`250`	`Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);`
`258`	`251`	`}`
`259`	`252`	`catch (Exception ex)`
`260`	`253`	`{`
`261`		`- _testOutputHelper.WriteLine(ex.ToString());`
	`254`	`+ testOutputHelper.WriteLine(ex.ToString());`
`262`	`255`	`throw;`
`263`	`256`	`}`
`264`	`257`	`finally`
`@@ -272,7 +265,7 @@ public async Task CustormEncoding_FindHelp()`
`272`	`265`	`{`
`273`	`266`	`var registry = new CollectorRegistry();`
`274`	`267`	`var factory = new MetricFactory(registry);`
`275`		`- _metricServer = new MetricServer(new MetricServerOptions { Port = _port, CollectorRegistryInstance = registry, ResponseEncoding = Encoding.UTF8 });`
	`268`	`+ _metricServer = new MetricServer(new MetricServerOptions { Port = fixture.Port, CollectorRegistryInstance = registry, ResponseEncoding = Encoding.UTF8 });`
`276`	`269`
`277`	`270`	`try`
`278`	`271`	`{`
`@@ -283,12 +276,12 @@ public async Task CustormEncoding_FindHelp()`
`283`	`276`	`counter.Inc();`
`284`	`277`
`285`	`278`	`using var httpClient = new HttpClient();`
`286`		`- string response = await httpClient.GetStringAsync($"http://localhost:{_port}{Defaults.MapPath}");`
	`279`	`+ string response = await httpClient.GetStringAsync($"http://localhost:{fixture.Port}{Defaults.MapPath}");`
`287`	`280`	`Assert.Contains(help, response);`
`288`	`281`	`}`
`289`	`282`	`catch (Exception ex)`
`290`	`283`	`{`
`291`		`- _testOutputHelper.WriteLine(ex.ToString());`
	`284`	`+ testOutputHelper.WriteLine(ex.ToString());`
`292`	`285`	`throw;`
`293`	`286`	`}`
`294`	`287`	`finally`