#nullable enable

​

namespace Cnh.SysConsole.AuditLogging.MessageBroker

{

    using System;

    using System.Threading.Tasks;

    using MassTransit;

    using MassTransit.Testing;

    using Microsoft.Extensions.DependencyInjection;

    using CNH.Products.Lib.Model.Contracts;

    using Cnh.SysConsole.AuditLogging.MessageBroker.Consumers.ProductsDomain;

    using NSubstitute;

    using Cnh.SysConsole.AuditLogging.ExternalServices.Http;

​

    public class Program

    {

        public static async Task Main()

        {

            var mockProductService = Substitute.For<IProductService>();

            mockProductService.CreateAsync()

                .Returns(999);

            var provider = new ServiceCollection()

                .AddScoped(_ => mockProductService)

                .AddMassTransitTestHarness(cfg =>

                {

                    cfg.AddConsumer<ProductCreatedConsumer>();                 

                })

                .BuildServiceProvider(true);

​

            var harness = provider.GetRequiredService<ITestHarness>();

​

            await harness.Start();

​

            /*

            var client = harness.GetRequestClient<IActiveProductCreatedEvent>();

​

            await client.GetResponse<IActiveProductCreatedEvent>(new

            {

                Id = Guid.NewGuid()

            });

            */

            await harness.Bus.Publish<IActiveProductCreatedEvent>(new

            {

                Id = Guid.NewGuid()

            });

            await harness.Stop();

        }

    }

}

​

namespace CNH.Products.Lib.Model.Contracts

{

    using System;

    public interface IActiveProductCreatedEvent

    {

        Guid Id { get; }

        string PartNumber { get; }

        string? Name { get; }

    }

}

​

namespace Cnh.SysConsole.AuditLogging.MessageBroker.Consumers.ProductsDomain

{

    using System;

    using System.Threading.Tasks;

    using MassTransit;

    using CNH.Products.Lib.Model.Contracts;

    using Microsoft.Extensions.Logging;

    using Cnh.SysConsole.AuditLogging.ExternalServices.Http;

    public class ProductCreatedConsumer : IConsumer<IActiveProductCreatedEvent>

    {

        private readonly ILogger<ProductCreatedConsumer> _logger;

        private readonly IProductService _productService;

        public ProductCreatedConsumer(ILogger<ProductCreatedConsumer> logger,

            IProductService productService)

        {

            _logger = logger;

            _productService = productService;

        }

        public async Task Consume(ConsumeContext<IActiveProductCreatedEvent> context)

        {

            var @event = context.Message;

            _logger.LogInformation("\n... Message received: {@IActiveProductCreatedEvent} ...\n", @event);

            int result = await _productService.CreateAsync();

            _logger.LogInformation("\n... Result = {@Result}\n", result);

        }

    }

}

​

namespace Cnh.SysConsole.AuditLogging.ExternalServices.Http

{

    using System.Threading.Tasks;

    using Microsoft.Extensions.Logging;

​

    public class ProductExternalHttpService : IProductService

    {

        private readonly ILogger<ProductExternalHttpService> _logger;

        public ProductExternalHttpService(ILogger<ProductExternalHttpService> logger)

        {

            _logger = logger;

        }

        public Task<int> CreateAsync()

        {

            _logger.LogInformation("\nCreate async()\n");

            return Task.FromResult(1);

        }

    }

    public interface IProductService

    {

        Task<int> CreateAsync();

    }

}