lmxopcua/tests/ZB.MOM.WW.OtOpcUa.Tests/Status/StatusWebServerTests.cs

using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Host.Status;
using ZB.MOM.WW.OtOpcUa.Tests.Helpers;

namespace ZB.MOM.WW.OtOpcUa.Tests.Status
{
    /// <summary>
    ///     Verifies the lightweight HTTP dashboard host that exposes bridge status to operators.
    /// </summary>
    public class StatusWebServerTests : IDisposable
    {
        private readonly HttpClient _client;
        private readonly int _port;
        private readonly StatusWebServer _server;

        /// <summary>
        ///     Starts a status web server on a random test port and prepares an HTTP client for endpoint assertions.
        /// </summary>
        public StatusWebServerTests()
        {
            _port = new Random().Next(18000, 19000);
            var reportService = new StatusReportService(new HealthCheckService(), 10);
            var mxClient = new FakeMxAccessClient();
            reportService.SetComponents(mxClient, null, null, null);
            _server = new StatusWebServer(reportService, _port);
            _server.Start();
            _client = new HttpClient { BaseAddress = new Uri($"http://localhost:{_port}") };
        }

        /// <summary>
        ///     Disposes the test HTTP client and stops the status web server.
        /// </summary>
        public void Dispose()
        {
            _client.Dispose();
            _server.Dispose();
        }

        /// <summary>
        ///     Confirms that the dashboard root responds with HTML content.
        /// </summary>
        [Fact]
        public async Task Root_ReturnsHtml200()
        {
            var response = await _client.GetAsync("/");
            response.StatusCode.ShouldBe(HttpStatusCode.OK);
            response.Content.Headers.ContentType?.MediaType.ShouldBe("text/html");
        }

        /// <summary>
        ///     Confirms that the JSON status endpoint responds successfully.
        /// </summary>
        [Fact]
        public async Task ApiStatus_ReturnsJson200()
        {
            var response = await _client.GetAsync("/api/status");
            response.StatusCode.ShouldBe(HttpStatusCode.OK);
            response.Content.Headers.ContentType?.MediaType.ShouldBe("application/json");
        }

        /// <summary>
        ///     Confirms that the health endpoint returns HTTP 200 when the bridge is healthy.
        /// </summary>
        [Fact]
        public async Task ApiHealth_Returns200WhenHealthy()
        {
            var response = await _client.GetAsync("/api/health");
            // FakeMxAccessClient starts as Connected → healthy
            response.StatusCode.ShouldBe(HttpStatusCode.OK);
            var body = await response.Content.ReadAsStringAsync();
            body.ShouldContain("healthy");
        }

        /// <summary>
        ///     Confirms that unknown dashboard routes return HTTP 404.
        /// </summary>
        [Fact]
        public async Task UnknownPath_Returns404()
        {
            var response = await _client.GetAsync("/unknown");
            response.StatusCode.ShouldBe(HttpStatusCode.NotFound);
        }

        /// <summary>
        ///     Confirms that unsupported HTTP methods are rejected with HTTP 405.
        /// </summary>
        [Fact]
        public async Task PostMethod_Returns405()
        {
            var response = await _client.PostAsync("/", new StringContent(""));
            response.StatusCode.ShouldBe(HttpStatusCode.MethodNotAllowed);
        }

        /// <summary>
        ///     Confirms that Start() returns false and logs a failure when the target port is
        ///     already bound by another listener. Regression guard for the stability-review 2026-04-13
        ///     Finding 2: OpcUaService now surfaces this return value into DashboardStartFailed.
        /// </summary>
        [Fact]
        public void Start_WhenPortInUse_ReturnsFalse()
        {
            var port = new Random().Next(19000, 19500);
            using var blocker = new HttpListener();
            blocker.Prefixes.Add($"http://localhost:{port}/");
            blocker.Start();

            var reportService = new StatusReportService(new HealthCheckService(), 10);
            reportService.SetComponents(new FakeMxAccessClient(), null, null, null);
            using var contested = new StatusWebServer(reportService, port);

            contested.Start().ShouldBeFalse();
        }

        /// <summary>
        ///     Confirms that cache-control headers disable caching for dashboard responses.
        /// </summary>
        [Fact]
        public async Task CacheHeaders_Present()
        {
            var response = await _client.GetAsync("/");
            response.Headers.CacheControl?.NoCache.ShouldBe(true);
            response.Headers.CacheControl?.NoStore.ShouldBe(true);
        }

        /// <summary>
        ///     Confirms that the /health route returns an HTML health page.
        /// </summary>
        [Fact]
        public async Task HealthPage_ReturnsHtml200()
        {
            var response = await _client.GetAsync("/health");
            response.StatusCode.ShouldBe(HttpStatusCode.OK);
            response.Content.Headers.ContentType?.MediaType.ShouldBe("text/html");
            var body = await response.Content.ReadAsStringAsync();
            body.ShouldContain("SERVICE LEVEL");
            body.ShouldContain("MXAccess");
        }

        /// <summary>
        ///     Confirms that /api/health returns rich JSON with component health details.
        /// </summary>
        [Fact]
        public async Task ApiHealth_ReturnsRichJson()
        {
            var response = await _client.GetAsync("/api/health");
            response.StatusCode.ShouldBe(HttpStatusCode.OK);
            response.Content.Headers.ContentType?.MediaType.ShouldBe("application/json");
            var body = await response.Content.ReadAsStringAsync();
            body.ShouldContain("ServiceLevel");
            body.ShouldContain("Components");
            body.ShouldContain("Uptime");
        }

        /// <summary>
        ///     Confirms that the server can be started and stopped cleanly.
        /// </summary>
        [Fact]
        public void StartStop_DoesNotThrow()
        {
            var server2 = new StatusWebServer(
                new StatusReportService(new HealthCheckService(), 10),
                new Random().Next(19000, 20000));
            server2.Start().ShouldBe(true);
            server2.IsRunning.ShouldBe(true);
            server2.Stop();
        }
    }
}