Notes

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using Schwab.Rps.DigitalFinancialGuide.Management.Bff.Logging;
using Schwab.Rps.DigitalFinancialGuide.Management.Bff.Logging.Interfaces;
using Schwab.Rps.DigitalFinancialGuide.Management.Bff.Models;
using System;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

namespace Schwab.Rps.DigitalFinancialGuide.Management.Bff.UnitTests.Logging
{
[TestClass]
public class SchwabPlanServiceLoggerTests
{
private Mock<ISplunkLogging> _mockSplunkLogging;
private Mock<IAppAuditLogging> _mockAppAuditLogging;
private Mock<IAppSupportLogging> _mockAppSupportLogging;
private SchwabPlanServiceLogger _logger;

[TestInitialize]
public void TestInitialize()
{
_mockSplunkLogging = new Mock<ISplunkLogging>();
_mockAppAuditLogging = new Mock<IAppAuditLogging>();
_mockAppSupportLogging = new Mock<IAppSupportLogging>();

_logger = new SchwabPlanServiceLogger("debug", _mockSplunkLogging.Object, _mockAppAuditLogging.Object, _mockAppSupportLogging.Object);
}

[TestMethod]
public async Task LogError_ShouldLogToSplunk_WhenLogLevelIsAboveNone()
{
// Arrange
var exception = new Exception("Test Exception");

// Act
await _logger.LogError(exception);

// Assert
_mockSplunkLogging.Verify(s => s.LogException(exception), Times.Once);
}

[TestMethod]
public async Task LogMessage_ShouldLogToSplunk_WhenLogLevelIsDebugOrHigher()
{
// Arrange
string message = "Test message";
LogLevel logLevel = LogLevel.Debug;

// Act
await _logger.LogMessage(message, logLevel);

// Assert
_mockSplunkLogging.Verify(s => s.LogMessage(message, logLevel), Times.Once);
}

[TestMethod]
public async Task LogSplunkMessage_ShouldLogToSplunkWithFunctionality_WhenLogLevelIsDebugOrHigher()
{
// Arrange
string message = "Test message";
string functionality = "TestFunctionality";
LogLevel logLevel = LogLevel.Debug;

// Act
await _logger.LogSplunkMessage(message, functionality, logLevel);

// Assert
_mockSplunkLogging.Verify(s => s.LogMessage(message, logLevel, functionality), Times.Once);
}

[TestMethod]
public async Task LogFrontEndMessage_ShouldLogToSplunk_WhenLogSeverityIsAboveNone()
{
// Arrange
var loggingEntity = new FrontEndLoggingEntity
{
LogLevel = "error",
Message = "Test message",
StackTrace = "Test stack trace",
Component = "Test component"
};

// Act
await _logger.LogFrontEndMessage(loggingEntity);

// Assert
_mockSplunkLogging.Verify(s => s.LogException(loggingEntity.Message, loggingEntity.StackTrace, loggingEntity.Component), Times.Once);
}

[TestMethod]
public async Task GetLogLevel_ShouldReturnCorrectLogLevel_WhenValidIntegerIsProvided()
{
// Act
var logLevel = await _logger.LogLevelFromInteger(3); // LogLevel.Warning

// Assert
Assert.AreEqual(LogLevel.Warning, logLevel);
}

[TestMethod]
public async Task GetLogLevel_ShouldReturnCorrectLogLevel_WhenValidStringIsProvided()
{
// Act
var logLevel = await _logger.LogLevelFromString("warning");

// Assert
Assert.AreEqual(LogLevel.Warning, logLevel);
}

[TestMethod]
public async Task GetLogLevel_ShouldReturnNone_WhenInvalidStringIsProvided()
{
// Act
var logLevel = await _logger.LogLevelFromString("invalid");

// Assert
Assert.AreEqual(LogLevel.None, logLevel);
}

[TestMethod]
public async Task GetLogLevel_ShouldLogError_WhenExceptionOccursInIntegerConversion()
{
// Arrange
var invalidLogLevel = 999;

// Act
var logLevel = await _logger.LogLevelFromInteger(invalidLogLevel);

// Assert
_mockSplunkLogging.Verify(s => s.LogException(It.IsAny<Exception>()), Times.Once);
Assert.AreEqual(LogLevel.None, logLevel);
}

[TestMethod]
public async Task GetLogLevel_ShouldLogError_WhenExceptionOccursInStringConversion()
{
// Arrange
var invalidLogLevel = "invalid";

// Act
var logLevel = await _logger.LogLevelFromString(invalidLogLevel);

// Assert
_mockSplunkLogging.Verify(s => s.LogException(It.IsAny<Exception>()), Times.Once);
Assert.AreEqual(LogLevel.None, logLevel);
}
}
}