Task 480 | Step 2 Unit Tests Execution | C# Online Compiler

Task 480 | Step 2 Unit Tests Execution by Jomo Lumina

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging; // Assuming ILogger is from Microsoft.Extensions.Logging
using Moq;
using Xunit;

// Mock classes for compilation and demonstration purposes.  These would be replaced with your actual implementations.
public class Market
{
    public string Name { get; set; }
    public string ShortName { get; set; }
    public MarketType MarketType { get; set; }
    public Dictionary<string, string> SpecifierValues { get; set; }
}

public class MarketType
{
    public string ShortNamePattern { get; set; }
    public string NamePattern { get; set; }
}

public class SignalRMessageSetting
{
    public bool EnableMarketsShortNameInMultiLive { get; set; }
    public bool EnableMarketsSyncStateSlim { get; set; }
}

public interface ISettingService
{
    Task<SignalRMessageSetting> GetSignalRMessageSettingAsync();
}

public interface IEventNotificationService
{
    Task SendMarketsAsync(IEnumerable<Market> markets, Guid eventId, bool enableMarketsSyncStateSlim);
}

public static class NameUtils
{
    public static string GenerateShortNameFromNamePattern(string pattern, List<string> teams, List<string> players, List<string> roster, Dictionary<string, string> specifierValues)
    {
        // Simplified implementation for demonstration.
        if (string.IsNullOrWhiteSpace(pattern))
        {
            throw new ArgumentException("Pattern cannot be null or whitespace.", nameof(pattern));
        }
        return pattern + "_" + string.Join("_", specifierValues.Values);
    }
}

public class EventData
{
    public List<string> Teams { get; set; } = new List<string>();
    public List<string> Players { get; set; } = new List<string>();
    public List<string> Roster { get; set; } = new List<string>();
}

public class MarketDataProcessor
{
    private readonly ISettingService _settingService;
    private readonly IEventNotificationService _eventNotificationService;
    private readonly ILogger _logger;
    private readonly bool _isInMultiLive;
    private readonly Guid _eventId;
    private readonly EventData _event;

    public MarketDataProcessor(ISettingService settingService, IEventNotificationService eventNotificationService, ILogger logger, bool isInMultiLive, Guid eventId, EventData @event)
    {
        _settingService = settingService ?? throw new ArgumentNullException(nameof(settingService));
        _eventNotificationService = eventNotificationService ?? throw new ArgumentNullException(nameof(eventNotificationService));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _isInMultiLive = isInMultiLive;
        _eventId = eventId;
        _event = @event ?? throw new ArgumentNullException(nameof(@event));
    }

    public async Task SendSignalRMarketsInternalAsync(IEnumerable<Market> markets)
    {
        if (markets == null)
        {
            throw new ArgumentNullException(nameof(markets));
        }

        SignalRMessageSetting setting = await _settingService.GetSignalRMessageSettingAsync();

        if (_isInMultiLive && setting.EnableMarketsShortNameInMultiLive)
        {
            foreach (var market in markets)
            {
                if (string.IsNullOrWhiteSpace(market.ShortName))
                {
                    try
                    {
                        string pattern = string.IsNullOrWhiteSpace(market.MarketType?.ShortNamePattern)
                            ? market.MarketType?.NamePattern
                            : market.MarketType?.ShortNamePattern;

                        if (string.IsNullOrWhiteSpace(pattern))
                        {
                            throw new InvalidOperationException($"Both ShortNamePattern and NamePattern are null or whitespace for market: {market.Name}");
                        }

                        market.ShortName = NameUtils.GenerateShortNameFromNamePattern(
                            pattern,
                            _event.Teams,
                            _event.Players,
                            _event.Roster,
                            market.SpecifierValues
                        );
                    }
                    catch (ArgumentException ex)
                    {
                        _logger.LogError(ex, "Error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);
                        market.ShortName = market.Name; // Fallback to full name
                    }
                    catch (InvalidOperationException ex)
                    {
                         _logger.LogError(ex, "Invalid Operation Error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);
                        market.ShortName = market.Name;
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Unexpected error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);
                        market.ShortName = market.Name; // Fallback to full name
                    }
                }
            }
        }

        await _eventNotificationService.SendMarketsAsync(markets, _eventId, setting.EnableMarketsSyncStateSlim);
    }
}

public class Program
{
    public static async Task Main()
    {
        Console.WriteLine("🔍 Discovering and Running Tests...\n");

        int totalPassed = 0, totalFailed = 0;

        // Get all test classes (those containing [Fact] or [Theory] methods)
        var testClasses = Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(t => t.GetMethods(BindingFlags.Instance | BindingFlags.Public)
                .Any(m => m.GetCustomAttribute<FactAttribute>() != null ||
                          m.GetCustomAttribute<TheoryAttribute>() != null))
            .ToList();

        foreach (var testClass in testClasses)
        {
            Console.WriteLine($"📌 Running tests in: {testClass.Name}");
            (int passed, int failed) = await RunTests(testClass);
            totalPassed += passed;
            totalFailed += failed;
            Console.WriteLine();
        }

        Console.WriteLine("\n📊 FINAL SUMMARY:");
        Console.WriteLine($"✅ Total Passed: {totalPassed}");
        Console.WriteLine($"❌ Total Failed: {totalFailed}");
        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");
        Console.WriteLine("\n✅ Test execution completed.");
    }

    private static async Task<(int passed, int failed)> RunTests(Type testClassType)
    {
        object testInstance = Activator.CreateInstance(testClassType);
        var testMethods = testClassType.GetMethods(BindingFlags.Instance | BindingFlags.Public)
            .Where(m => m.GetCustomAttribute<FactAttribute>() != null ||
                        m.GetCustomAttribute<TheoryAttribute>() != null)
            .ToArray();

        int passed = 0, failed = 0;

        foreach (var method in testMethods)
        {
            try
            {
                var result = method.Invoke(testInstance, method.GetParameters().Length == 0 ? null : new object[method.GetParameters().Length]);
                if (result is Task task) await task; // Await async test methods
                Console.WriteLine($"  ✅ {method.Name} PASSED");
                passed++;
            }
            catch (TargetInvocationException ex)
            {
                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");
                failed++;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");
                failed++;
            }
        }

        return (passed, failed);
    }
}

// Mock implementations for testing
public class MockSettingService : ISettingService
{
    public async Task<SignalRMessageSetting> GetSignalRMessageSettingAsync()
    {
        // Simulate fetching settings
        await Task.Delay(10); // Simulate async operation
        return new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true, EnableMarketsSyncStateSlim = false };
    }
}

public class MockEventNotificationService : IEventNotificationService
{
    public async Task SendMarketsAsync(IEnumerable<Market> markets, Guid eventId, bool enableMarketsSyncStateSlim)
    {
        // Simulate sending data
        await Task.Delay(20); // Simulate async operation
        Console.WriteLine($"Sending markets for event {eventId}, EnableMarketsSyncStateSlim: {enableMarketsSyncStateSlim}");
    }
}

public class MarketDataProcessorTests
{
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_NullMarkets_ThrowsArgumentNullException()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
        var loggerMock = new Mock<ILogger>();
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, false, Guid.NewGuid(), new EventData());

        // Act & Assert
        await Assert.ThrowsAsync<ArgumentNullException>(() => processor.SendSignalRMarketsInternalAsync(null));
    }

    [Fact]
    public async Task SendSignalRMarketsInternalAsync_NotInMultiLive_DoesNotGenerateShortNames()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
        var loggerMock = new Mock<ILogger>();
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, false, Guid.NewGuid(), new EventData());
        var markets = new List<Market> { new Market { Name = "Market 1" } };

        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);

        // Assert
        Assert.Null(markets[0].ShortName); // ShortName should not be generated
        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), It.IsAny<bool>()), Times.Once);
    }

    [Fact]
    public async Task SendSignalRMarketsInternalAsync_ShortNamesDisabled_DoesNotGenerateShortNames()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = false });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
        var loggerMock = new Mock<ILogger>();
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), new EventData());
        var markets = new List<Market> { new Market { Name = "Market 1" } };

        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);

        // Assert
        Assert.Null(markets[0].ShortName); // ShortName should not be generated
        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), It.IsAny<bool>()), Times.Once);
    }

    [Fact]
    public async Task SendSignalRMarketsInternalAsync_GeneratesShortNames_Success()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
        var loggerMock = new Mock<ILogger>();

        var eventData = new EventData
        {
            Teams = new List<string> { "TeamA", "TeamB" },
            Players = new List<string> { "PlayerX", "PlayerY" },
            Roster = new List<string> {"RosterAlpha", "RosterBeta"}
        };

        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);
        var markets = new List<Market>
        {
            new Market { Name = "Market 1", MarketType = new MarketType { ShortNamePattern = "Pattern1" }, SpecifierValues = new Dictionary<string, string>{{"key1", "Value1"}}},
            new Market { Name = "Market 2", ShortName = "ExistingShortName", MarketType = new MarketType { ShortNamePattern = "Pattern2" }, SpecifierValues = new Dictionary<string, string>{{"key2", "Value2"}}} // Already has a short name
        };

        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);

        // Assert
        Assert.Equal("Pattern1_Value1", markets[0].ShortName);
        Assert.Equal("ExistingShortName", markets[1].ShortName); // Existing short name should not be changed
        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), It.IsAny<bool>()), Times.Once);
    }
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_NullMarketType_LogsErrorAndUsesFullName()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true, EnableMarketsSyncStateSlim = true });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();

        var loggerMock = new Mock<ILogger>();
        var eventData = new EventData
        {
             Teams = new List<string> { "TeamA", "TeamB" },
            Players = new List<string> { "PlayerX", "PlayerY" },
            Roster = new List<string> {"RosterAlpha", "RosterBeta"}
        };
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);
        var markets = new List<Market> { new Market { Name = "Market 1", MarketType = null, SpecifierValues = new () } };

        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);

        // Assert
        Assert.Equal("Market 1", markets[0].ShortName); // Should fallback to full name.
        loggerMock.Verify(l => l.Log(
                It.Is<LogLevel>(logLevel => logLevel == LogLevel.Error),
                It.IsAny<EventId>(),
                It.Is<It.IsAnyType>((v, t) => v.ToString().StartsWith("Invalid Operation Error generating short name for market Market 1")),
                It.IsAny<Exception>(),
                It.IsAny<Func<It.IsAnyType, Exception, string>>()),
            Times.Once);
        eventNotificationServiceMock.Verify(e=>e.SendMarketsAsync(markets, It.IsAny<Guid>(), true), Times.Once);

    }
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_EmptyShortAndNamePattern_LogsErrorAndUsesFullName()
    {
          // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true, EnableMarketsSyncStateSlim = true });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();

        var loggerMock = new Mock<ILogger>();
        var eventData = new EventData
        {
             Teams = new List<string> { "TeamA", "TeamB" },
            Players = new List<string> { "PlayerX", "PlayerY" },
            Roster = new List<string> {"RosterAlpha", "RosterBeta"}
        };
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);
        var markets = new List<Market> { new Market { Name = "Market 1", MarketType = new MarketType{ ShortNamePattern = "", NamePattern = null}, SpecifierValues = new () } };

        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);

        // Assert
        Assert.Equal("Market 1", markets[0].ShortName); // Should fallback to full name.
        loggerMock.Verify(l => l.Log(
                It.Is<LogLevel>(logLevel => logLevel == LogLevel.Error),
                It.IsAny<EventId>(),
                It.Is<It.IsAnyType>((v, t) => v.ToString().StartsWith("Invalid Operation Error generating short name for market Market 1")),
                It.IsAny<Exception>(),
                It.IsAny<Func<It.IsAnyType, Exception, string>>()),
            Times.Once);
        eventNotificationServiceMock.Verify(e=>e.SendMarketsAsync(markets, It.IsAny<Guid>(), true), Times.Once);
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging; // Assuming ILogger is from Microsoft.Extensions.Logging
using Moq;
using Xunit;
​
// Mock classes for compilation and demonstration purposes.  These would be replaced with your actual implementations.
public class Market
{
    public string Name { get; set; }
    public string ShortName { get; set; }
    public MarketType MarketType { get; set; }
    public Dictionary<string, string> SpecifierValues { get; set; }
}
​
public class MarketType
{
    public string ShortNamePattern { get; set; }
    public string NamePattern { get; set; }
}
​
public class SignalRMessageSetting
{
    public bool EnableMarketsShortNameInMultiLive { get; set; }
    public bool EnableMarketsSyncStateSlim { get; set; }
}
​
public interface ISettingService
{
    Task<SignalRMessageSetting> GetSignalRMessageSettingAsync();
}
​
public interface IEventNotificationService
{
    Task SendMarketsAsync(IEnumerable<Market> markets, Guid eventId, bool enableMarketsSyncStateSlim);
}
​
public static class NameUtils
{
    public static string GenerateShortNameFromNamePattern(string pattern, List<string> teams, List<string> players, List<string> roster, Dictionary<string, string> specifierValues)
    {
        // Simplified implementation for demonstration.
        if (string.IsNullOrWhiteSpace(pattern))
        {
            throw new ArgumentException("Pattern cannot be null or whitespace.", nameof(pattern));
        }
        return pattern + "_" + string.Join("_", specifierValues.Values);
    }
}
​
public class EventData
{
    public List<string> Teams { get; set; } = new List<string>();
    public List<string> Players { get; set; } = new List<string>();
    public List<string> Roster { get; set; } = new List<string>();
}
​
public class MarketDataProcessor
{
    private readonly ISettingService _settingService;
    private readonly IEventNotificationService _eventNotificationService;
    private readonly ILogger _logger;
    private readonly bool _isInMultiLive;
    private readonly Guid _eventId;
    private readonly EventData _event;
​
    public MarketDataProcessor(ISettingService settingService, IEventNotificationService eventNotificationService, ILogger logger, bool isInMultiLive, Guid eventId, EventData @event)
    {
        _settingService = settingService ?? throw new ArgumentNullException(nameof(settingService));
        _eventNotificationService = eventNotificationService ?? throw new ArgumentNullException(nameof(eventNotificationService));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _isInMultiLive = isInMultiLive;
        _eventId = eventId;
        _event = @event ?? throw new ArgumentNullException(nameof(@event));
    }
​
    public async Task SendSignalRMarketsInternalAsync(IEnumerable<Market> markets)
    {
        if (markets == null)
        {
            throw new ArgumentNullException(nameof(markets));
        }
​
        SignalRMessageSetting setting = await _settingService.GetSignalRMessageSettingAsync();
​
        if (_isInMultiLive && setting.EnableMarketsShortNameInMultiLive)
        {
            foreach (var market in markets)
            {
                if (string.IsNullOrWhiteSpace(market.ShortName))
                {
                    try
                    {
                        string pattern = string.IsNullOrWhiteSpace(market.MarketType?.ShortNamePattern)
                            ? market.MarketType?.NamePattern
                            : market.MarketType?.ShortNamePattern;
​
                        if (string.IsNullOrWhiteSpace(pattern))
                        {
                            throw new InvalidOperationException($"Both ShortNamePattern and NamePattern are null or whitespace for market: {market.Name}");
                        }
​
                        market.ShortName = NameUtils.GenerateShortNameFromNamePattern(
                            pattern,
                            _event.Teams,
                            _event.Players,
                            _event.Roster,
                            market.SpecifierValues
                        );
                    }
                    catch (ArgumentException ex)
                    {
                        _logger.LogError(ex, "Error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);
                        market.ShortName = market.Name; // Fallback to full name
                    }
                    catch (InvalidOperationException ex)
                    {
                         _logger.LogError(ex, "Invalid Operation Error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);
                        market.ShortName = market.Name;
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Unexpected error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);
                        market.ShortName = market.Name; // Fallback to full name
                    }
                }
            }
        }
​
        await _eventNotificationService.SendMarketsAsync(markets, _eventId, setting.EnableMarketsSyncStateSlim);
    }
}
​
public class Program
{
    public static async Task Main()
    {
        Console.WriteLine("🔍 Discovering and Running Tests...\n");
​
        int totalPassed = 0, totalFailed = 0;
​
        // Get all test classes (those containing [Fact] or [Theory] methods)
        var testClasses = Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(t => t.GetMethods(BindingFlags.Instance | BindingFlags.Public)
                .Any(m => m.GetCustomAttribute<FactAttribute>() != null ||
                          m.GetCustomAttribute<TheoryAttribute>() != null))
            .ToList();
​
        foreach (var testClass in testClasses)
        {
            Console.WriteLine($"📌 Running tests in: {testClass.Name}");
            (int passed, int failed) = await RunTests(testClass);
            totalPassed += passed;
            totalFailed += failed;
            Console.WriteLine();
        }
​
        Console.WriteLine("\n📊 FINAL SUMMARY:");
        Console.WriteLine($"✅ Total Passed: {totalPassed}");
        Console.WriteLine($"❌ Total Failed: {totalFailed}");
        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");
        Console.WriteLine("\n✅ Test execution completed.");
    }
​
    private static async Task<(int passed, int failed)> RunTests(Type testClassType)
    {
        object testInstance = Activator.CreateInstance(testClassType);
        var testMethods = testClassType.GetMethods(BindingFlags.Instance | BindingFlags.Public)
            .Where(m => m.GetCustomAttribute<FactAttribute>() != null ||
                        m.GetCustomAttribute<TheoryAttribute>() != null)
            .ToArray();
​
        int passed = 0, failed = 0;
​
        foreach (var method in testMethods)
        {
            try
            {
                var result = method.Invoke(testInstance, method.GetParameters().Length == 0 ? null : new object[method.GetParameters().Length]);
                if (result is Task task) await task; // Await async test methods
                Console.WriteLine($"  ✅ {method.Name} PASSED");
                passed++;
            }
            catch (TargetInvocationException ex)
            {
                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");
                failed++;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");
                failed++;
            }
        }
​
        return (passed, failed);
    }
}
​
// Mock implementations for testing
public class MockSettingService : ISettingService
{
    public async Task<SignalRMessageSetting> GetSignalRMessageSettingAsync()
    {
        // Simulate fetching settings
        await Task.Delay(10); // Simulate async operation
        return new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true, EnableMarketsSyncStateSlim = false };
    }
}
​
public class MockEventNotificationService : IEventNotificationService
{
    public async Task SendMarketsAsync(IEnumerable<Market> markets, Guid eventId, bool enableMarketsSyncStateSlim)
    {
        // Simulate sending data
        await Task.Delay(20); // Simulate async operation
        Console.WriteLine($"Sending markets for event {eventId}, EnableMarketsSyncStateSlim: {enableMarketsSyncStateSlim}");
    }
}
​
public class MarketDataProcessorTests
{
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_NullMarkets_ThrowsArgumentNullException()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
        var loggerMock = new Mock<ILogger>();
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, false, Guid.NewGuid(), new EventData());
​
        // Act & Assert
        await Assert.ThrowsAsync<ArgumentNullException>(() => processor.SendSignalRMarketsInternalAsync(null));
    }
​
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_NotInMultiLive_DoesNotGenerateShortNames()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
        var loggerMock = new Mock<ILogger>();
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, false, Guid.NewGuid(), new EventData());
        var markets = new List<Market> { new Market { Name = "Market 1" } };
​
        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);
​
        // Assert
        Assert.Null(markets[0].ShortName); // ShortName should not be generated
        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), It.IsAny<bool>()), Times.Once);
    }
​
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_ShortNamesDisabled_DoesNotGenerateShortNames()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = false });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
        var loggerMock = new Mock<ILogger>();
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), new EventData());
        var markets = new List<Market> { new Market { Name = "Market 1" } };
​
        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);
​
        // Assert
        Assert.Null(markets[0].ShortName); // ShortName should not be generated
        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), It.IsAny<bool>()), Times.Once);
    }
​
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_GeneratesShortNames_Success()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
        var loggerMock = new Mock<ILogger>();
​
        var eventData = new EventData
        {
            Teams = new List<string> { "TeamA", "TeamB" },
            Players = new List<string> { "PlayerX", "PlayerY" },
            Roster = new List<string> {"RosterAlpha", "RosterBeta"}
        };
​
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);
        var markets = new List<Market>
        {
            new Market { Name = "Market 1", MarketType = new MarketType { ShortNamePattern = "Pattern1" }, SpecifierValues = new Dictionary<string, string>{{"key1", "Value1"}}},
            new Market { Name = "Market 2", ShortName = "ExistingShortName", MarketType = new MarketType { ShortNamePattern = "Pattern2" }, SpecifierValues = new Dictionary<string, string>{{"key2", "Value2"}}} // Already has a short name
        };
​
        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);
​
        // Assert
        Assert.Equal("Pattern1_Value1", markets[0].ShortName);
        Assert.Equal("ExistingShortName", markets[1].ShortName); // Existing short name should not be changed
        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), It.IsAny<bool>()), Times.Once);
    }
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_NullMarketType_LogsErrorAndUsesFullName()
    {
        // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true, EnableMarketsSyncStateSlim = true });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
​
        var loggerMock = new Mock<ILogger>();
        var eventData = new EventData
        {
             Teams = new List<string> { "TeamA", "TeamB" },
            Players = new List<string> { "PlayerX", "PlayerY" },
            Roster = new List<string> {"RosterAlpha", "RosterBeta"}
        };
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);
        var markets = new List<Market> { new Market { Name = "Market 1", MarketType = null, SpecifierValues = new () } };
​
        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);
​
        // Assert
        Assert.Equal("Market 1", markets[0].ShortName); // Should fallback to full name.
        loggerMock.Verify(l => l.Log(
                It.Is<LogLevel>(logLevel => logLevel == LogLevel.Error),
                It.IsAny<EventId>(),
                It.Is<It.IsAnyType>((v, t) => v.ToString().StartsWith("Invalid Operation Error generating short name for market Market 1")),
                It.IsAny<Exception>(),
                It.IsAny<Func<It.IsAnyType, Exception, string>>()),
            Times.Once);
        eventNotificationServiceMock.Verify(e=>e.SendMarketsAsync(markets, It.IsAny<Guid>(), true), Times.Once);
​
    }
    [Fact]
    public async Task SendSignalRMarketsInternalAsync_EmptyShortAndNamePattern_LogsErrorAndUsesFullName()
    {
          // Arrange
        var settingServiceMock = new Mock<ISettingService>();
        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(new SignalRMessageSetting { EnableMarketsShortNameInMultiLive = true, EnableMarketsSyncStateSlim = true });
        var eventNotificationServiceMock = new Mock<IEventNotificationService>();
​
        var loggerMock = new Mock<ILogger>();
        var eventData = new EventData
        {
             Teams = new List<string> { "TeamA", "TeamB" },
            Players = new List<string> { "PlayerX", "PlayerY" },
            Roster = new List<string> {"RosterAlpha", "RosterBeta"}
        };
        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);
        var markets = new List<Market> { new Market { Name = "Market 1", MarketType = new MarketType{ ShortNamePattern = "", NamePattern = null}, SpecifierValues = new () } };
​
        // Act
        await processor.SendSignalRMarketsInternalAsync(markets);
​
        // Assert
        Assert.Equal("Market 1", markets[0].ShortName); // Should fallback to full name.
        loggerMock.Verify(l => l.Log(
                It.Is<LogLevel>(logLevel => logLevel == LogLevel.Error),
                It.IsAny<EventId>(),
                It.Is<It.IsAnyType>((v, t) => v.ToString().StartsWith("Invalid Operation Error generating short name for market Market 1")),
                It.IsAny<Exception>(),
                It.IsAny<Func<It.IsAnyType, Exception, string>>()),
            Times.Once);
        eventNotificationServiceMock.Verify(e=>e.SendMarketsAsync(markets, It.IsAny<Guid>(), true), Times.Once);
    }
}

Hello World

Cached Result
Last Run:	1:43:05 pm
Compile:	0.423s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code