haoliang/Haoliang.Tests/Controllers/DeviceControllerTests.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Moq;
using FluentAssertions;
using Xunit;
using Haoliang.Api.Controllers;
using Haoliang.Core.Services;
using Haoliang.Models.Common;
using Haoliang.Models.Device;
using Haoliang.Models.Production;

namespace Haoliang.Tests.Controllers
{
    public class DeviceControllerTests
    {
        private readonly Mock<IDeviceCollectionService> _collectionService;
        private readonly Mock<IProductionService> _productionService;
        private readonly Mock<IAlarmService> _alarmService;
        private readonly Mock<ITemplateService> _templateService;
        private readonly Mock<ISystemConfigService> _configService;
        private readonly Mock<ILoggingService> _loggingService;
        private readonly DeviceController _controller;

        public DeviceControllerTests()
        {
            _collectionService = new Mock<IDeviceCollectionService>();
            _productionService = new Mock<IProductionService>();
            _alarmService = new Mock<IAlarmService>();
            _templateService = new Mock<ITemplateService>();
            _configService = new Mock<ISystemConfigService>();
            _loggingService = new Mock<ILoggingService>();
            _controller = new DeviceController(
                _collectionService.Object,
                _productionService.Object,
                _alarmService.Object,
                _templateService.Object,
                _configService.Object,
                _loggingService.Object);
        }

        [Fact]
        public async Task GetAllDevices_WhenSuccess_ReturnsOk()
        {
            _collectionService.Setup(s => s.GetAllDevicesAsync())
                .ReturnsAsync(new List<CNCDevice>());

            var result = await _controller.GetAllDevices();

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task GetAllDevices_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.GetAllDevicesAsync())
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.GetAllDevices();

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task GetDevice_WhenFound_ReturnsOk()
        {
            _collectionService.Setup(s => s.GetDeviceByIdAsync(1))
                .ReturnsAsync(new CNCDevice());

            var result = await _controller.GetDevice(1);

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task GetDevice_WhenNotFound_ReturnsNotFound()
        {
            _collectionService.Setup(s => s.GetDeviceByIdAsync(999))
                .ReturnsAsync((CNCDevice?)null);

            var result = await _controller.GetDevice(999);

            result.Should().BeOfType<NotFoundObjectResult>();
        }

        [Fact]
        public async Task GetDevice_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.GetDeviceByIdAsync(It.IsAny<int>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.GetDevice(1);

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task CreateDevice_WhenSuccess_ReturnsOk()
        {
            _collectionService.Setup(s => s.CreateDeviceAsync(It.IsAny<CNCDevice>()))
                .ReturnsAsync(new CNCDevice());

            var result = await _controller.CreateDevice(new CNCDevice());

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task CreateDevice_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.CreateDeviceAsync(It.IsAny<CNCDevice>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.CreateDevice(new CNCDevice());

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task UpdateDevice_WhenFound_ReturnsOk()
        {
            _collectionService.Setup(s => s.UpdateDeviceAsync(It.IsAny<CNCDevice>()))
                .ReturnsAsync(new CNCDevice());

            var result = await _controller.UpdateDevice(1, new CNCDevice());

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task UpdateDevice_WhenNotFound_ReturnsNotFound()
        {
            _collectionService.Setup(s => s.UpdateDeviceAsync(It.IsAny<CNCDevice>()))
                .ReturnsAsync((CNCDevice?)null);

            var result = await _controller.UpdateDevice(999, new CNCDevice());

            result.Should().BeOfType<NotFoundObjectResult>();
        }

        [Fact]
        public async Task UpdateDevice_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.UpdateDeviceAsync(It.IsAny<CNCDevice>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.UpdateDevice(1, new CNCDevice());

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task DeleteDevice_WhenFound_ReturnsOk()
        {
            _collectionService.Setup(s => s.DeleteDeviceAsync(1))
                .ReturnsAsync(true);

            var result = await _controller.DeleteDevice(1);

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task DeleteDevice_WhenNotFound_ReturnsNotFound()
        {
            _collectionService.Setup(s => s.DeleteDeviceAsync(999))
                .ReturnsAsync(false);

            var result = await _controller.DeleteDevice(999);

            result.Should().BeOfType<NotFoundObjectResult>();
        }

        [Fact]
        public async Task DeleteDevice_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.DeleteDeviceAsync(It.IsAny<int>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.DeleteDevice(1);

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task CollectDeviceData_WhenSuccess_ReturnsOk()
        {
            var result = await _controller.CollectDeviceData(1);

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task CollectDeviceData_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.CollectDeviceAsync(It.IsAny<int>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.CollectDeviceData(1);

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task CollectAllDevices_WhenSuccess_ReturnsOk()
        {
            var result = await _controller.CollectAllDevices();

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task CollectAllDevices_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.CollectAllDevicesAsync())
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.CollectAllDevices();

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task GetDeviceStatus_WhenSuccess_ReturnsOk()
        {
            _collectionService.Setup(s => s.GetDeviceStatusAsync(1))
                .ReturnsAsync(new Haoliang.Core.Services.DeviceStatus());

            var result = await _controller.GetDeviceStatus(1);

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task GetDeviceStatus_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.GetDeviceStatusAsync(It.IsAny<int>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.GetDeviceStatus(1);

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task GetDeviceProduction_WhenSuccess_ReturnsOk()
        {
            _productionService.Setup(s => s.GetTodayProductionAsync(1))
                .ReturnsAsync(new ProductionRecord());

            var result = await _controller.GetDeviceProduction(1, DateTime.Today);

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task GetDeviceProduction_WhenException_Returns500()
        {
            _productionService.Setup(s => s.GetTodayProductionAsync(It.IsAny<int>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.GetDeviceProduction(1, DateTime.Today);

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task GetDeviceAlarms_WhenSuccess_ReturnsOk()
        {
            _alarmService.Setup(s => s.GetDeviceAlarmsAsync(1, 7))
                .ReturnsAsync(new List<Haoliang.Models.System.Alarm>());

            var result = await _controller.GetDeviceAlarms(1);

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task GetDeviceAlarms_WhenException_Returns500()
        {
            _alarmService.Setup(s => s.GetDeviceAlarmsAsync(It.IsAny<int>(), It.IsAny<int>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.GetDeviceAlarms(1);

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }

        [Fact]
        public async Task GetDeviceHealth_WhenSuccess_ReturnsOk()
        {
            _collectionService.Setup(s => s.GetDeviceHealthAsync(1))
                .ReturnsAsync(new DeviceHealth());

            var result = await _controller.GetDeviceHealth(1);

            result.Should().BeOfType<OkObjectResult>();
        }

        [Fact]
        public async Task GetDeviceHealth_WhenException_Returns500()
        {
            _collectionService.Setup(s => s.GetDeviceHealthAsync(It.IsAny<int>()))
                .ThrowsAsync(new Exception("test"));

            var result = await _controller.GetDeviceHealth(1);

            var objResult = result.Should().BeOfType<ObjectResult>().Subject;
            objResult.StatusCode.Should().Be(500);
        }
    }
}