// UnitTests.cs

using Bunit;

using Microsoft.Extensions.DependencyInjection;

using NUnit.Framework;

using Moq;

using Microsoft.JSInterop;

using Microsoft.Extensions.Logging;

using System.Threading.Tasks;

using Microsoft.AspNetCore.Components;

using System;

using NUnitLite;

​

public class Program

{

    public static int Main(string[] args)

    {

        return new AutoRun().Execute(args);

    }

}

​

namespace BlazorCamera

{

    public partial class CameraView : ComponentBase, IDisposable

    {

        [Inject]

        private IJSRuntime JsRuntime { get; set; } = default!;

​

        [Inject]

        private ILogger<CameraView> Logger { get; set; } = default!;

​

        [Parameter]

        public string VideoElementId { get; set; } = "cameraVideo"; // Default value

​

        private bool _isCameraActive = false;

        private string _errorMessage = string.Empty;

        private IJSObjectReference? _module;

​

        protected override async Task OnAfterRenderAsync(bool firstRender)

        {

            if (firstRender)

            {

                try

                {

                    _module = await JsRuntime.InvokeAsync<IJSObjectReference>("import", "./js/camera.js");

                }

                catch (JSException ex)

                {

                    _errorMessage = $"Error loading JavaScript module: {ex.Message}";

                    Logger.LogError(ex, "Error loading camera.js");

                    StateHasChanged(); // Update UI to display error

                }

            }

        }

​

        public async Task StartCamera()

        {

            if (_module is null)

            {

                _errorMessage = "JavaScript module not loaded.";

                Logger.LogError("JavaScript module not loaded.");

                StateHasChanged();

                return;

            }

​

            if (string.IsNullOrEmpty(VideoElementId))

            {

                _errorMessage = "Video element ID is not set.";

                Logger.LogError("Video element ID is not set.");

                StateHasChanged();

                return;

            }

​

            try

            {

                await _module.InvokeVoidAsync("startCamera", VideoElementId, DotNetObjectReference.Create(this));

                _isCameraActive = true;

                _errorMessage = string.Empty;

            }

            catch (JSException ex)

            {

                _errorMessage = $"Error starting camera: {ex.Message}";

                Logger.LogError(ex, "Error starting camera.");

                _isCameraActive = false;

            }

            finally

            {

                StateHasChanged();

            }

        }

​

​

        public async Task StopCamera()

        {

            if (_module is not null && _isCameraActive)

            {

                try

                {

                    await _module.InvokeVoidAsync("stopCamera");

                    _isCameraActive = false;

                    _errorMessage = string.Empty;

                }

                catch (JSException ex)

                {

                    _errorMessage = $"Error stopping camera: {ex.Message}";

                    Logger.LogError(ex, "Error stopping camera.");

                }

                finally

                {

                    StateHasChanged();

                }

            }

        }

​

        [JSInvokable]

        public void OnCameraError(string message)

        {

            _errorMessage = $"Camera error: {message}";

            Logger.LogError("Camera error: {Message}", message);

            _isCameraActive = false;

            StateHasChanged();

        }

​

        public void Dispose()

        {

            _ = StopCamera(); // Stop camera on dispose

            _module?.DisposeAsync();

        }

    }

}

​

namespace BlazorCamera.Tests

{

    public class CameraViewTests

    {

        private Bunit.TestContext _testContext;

        private Mock<IJSRuntime> _jsRuntimeMock;

        private Mock<ILogger<CameraView>> _loggerMock;

​

        [SetUp]

        public void Setup()

        {

            _testContext = new Bunit.TestContext();

            _jsRuntimeMock = new Mock<IJSRuntime>();

            _loggerMock = new Mock<ILogger<CameraView>>();

​

            _testContext.Services.AddSingleton(_jsRuntimeMock.Object);

            _testContext.Services.AddSingleton(_loggerMock.Object);

        }

​

        [TearDown]

        public void TearDown()

        {

            _testContext.Dispose();

        }

​

​

        [Test]

        public async Task StartCamera_ValidId_CallsJsInterop()

        {

            // Arrange

            _jsRuntimeMock.Setup(j => j.InvokeVoidAsync(

                    "camera.startCamera",

                    "testVideo",

                    It.IsAny<object>()))

                .Returns(ValueTask.CompletedTask);

​

            var component = _testContext.RenderComponent<CameraView>(parameters => parameters.Add(p => p.VideoElementId, "testVideo"));

​

            // Act

            await component.Instance.StartCamera();

​

            // Assert

            _jsRuntimeMock.Verify(j => j.InvokeVoidAsync(

                    "camera.startCamera",

                    "testVideo",

                    It.IsAny<object>()), Times.Once);

        }

​

        [Test]

        public async Task StartCamera_EmptyId_LogsError()

        {

            // Arrange

            var component = _testContext.RenderComponent<CameraView>(parameters => parameters.Add(p => p.VideoElementId, ""));

​

            // Act

            await component.Instance.StartCamera();

​

            // Assert

            _loggerMock.Verify(

                x => x.Log(

                    LogLevel.Error,

                    It.IsAny<EventId>(),

                    It.Is<It.IsAnyType>((o, t) => o.ToString()!.Contains("Video element ID is not set.")),

                    It.IsAny<Exception>(),

                    (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()),

                Times.Once);

        }

​

        [Test]

        public async Task StopCamera_CameraActive_CallsJsInterop()

        {

            // Arrange

            _jsRuntimeMock.Setup(j => j.InvokeVoidAsync("camera.stopCamera"))

                .Returns(ValueTask.CompletedTask);

​

            var component = _testContext.RenderComponent<CameraView>(parameters => parameters.Add(p => p.VideoElementId, "testVideo"));

            await component.Instance.StartCamera(); // Simulate camera being active

​

            // Act

            await component.Instance.StopCamera();

​

            // Assert

            _jsRuntimeMock.Verify(j => j.InvokeVoidAsync("camera.stopCamera"), Times.Once);

        }

​

        [Test]

        public async Task StopCamera_CameraNotActive_DoesNotCallJsInterop()

        {

            // Arrange

            var component = _testContext.RenderComponent<CameraView>(parameters => parameters.Add(p => p.VideoElementId, "testVideo"));

​

            // Act

            await component.Instance.StopCamera();

​

            // Assert

            _jsRuntimeMock.Verify(j => j.InvokeVoidAsync(It.IsAny<string>()), Times.Never);

        }

​

​

        [Test]

        public async Task OnCameraError_SetsErrorMessage()

        {

            // Arrange

            var component = _testContext.RenderComponent<CameraView>();

​

            // Act

            component.Instance.OnCameraError("Permission Denied");

            component.Render();

​

            // Assert

            Assert.That(component.Find(".alert").TextContent, Is.EqualTo("Camera error: Permission Denied"));

        }

​

        [Test]

        public async Task StartCamera_JsException_LogsError()

        {

            // Arrange

            _jsRuntimeMock.Setup(j => j.InvokeVoidAsync(

                    "camera.startCamera",

                    It.IsAny<string>(),

                    It.IsAny<object>()))

                .ThrowsAsync(new JSException("Test Exception"));

​

            var component = _testContext.RenderComponent<CameraView>(parameters => parameters.Add(p => p.VideoElementId, "testVideo"));

​

            // Act

            await component.Instance.StartCamera();

​

            // Assert

            _loggerMock.Verify(

                x => x.Log(

                    LogLevel.Error,

                    It.IsAny<EventId>(),

                    It.Is<It.IsAnyType>((o, t) => o.ToString()!.Contains("Error starting camera: Test Exception")),

                    It.IsAny<JSException>(),

                    (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()),

                Times.Once);

        }

​

        [Test]

        public async Task Dispose_StopsCamera()

        {

            // Arrange

            _jsRuntimeMock.Setup(j => j.InvokeVoidAsync("camera.stopCamera"))

                .Returns(ValueTask.CompletedTask);

​

            var component = _testContext.RenderComponent<CameraView>(parameters => parameters.Add(p => p.VideoElementId, "testVideo"));

            await component.Instance.StartCamera();

​

            // Act

            component.Dispose();

​

            // Assert

            _jsRuntimeMock.Verify(j => j.InvokeVoidAsync("camera.stopCamera"), Times.Once);

        }

​

        [Test]

        public async Task StartStopStartCamera_MultipleCalls()

        {

            // Arrange

            _jsRuntimeMock.Setup(j => j.InvokeVoidAsync(

                    "camera.startCamera",

                    It.IsAny<string>(),

                    It.IsAny<object>()))

                .Returns(ValueTask.CompletedTask);

​

            _jsRuntimeMock.Setup(j => j.InvokeVoidAsync("camera.stopCamera"))

                .Returns(ValueTask.CompletedTask);

​

            var component = _testContext.RenderComponent<CameraView>(parameters => parameters.Add(p => p.VideoElementId, "testVideo"));

​

            // Act

            await component.Instance.StartCamera();

            await component.Instance.StopCamera();

            await component.Instance.StartCamera();

​

            // Assert

            _jsRuntimeMock.Verify(j => j.InvokeVoidAsync("camera.startCamera", It.IsAny<string>(), It.IsAny<object>()), Times.Exactly(2));

            _jsRuntimeMock.Verify(j => j.InvokeVoidAsync("camera.stopCamera"), Times.Once);

        }

    }

}