FruitBankHybridApp/FruitBankHybrid.Shared.Tests/FruitBankClientTests.cs

using AyCode.Core.Enums;
using AyCode.Core.Extensions;
using AyCode.Core.Loggers;
using AyCode.Utils.Extensions;
using FruitBank.Common.Entities;
using FruitBank.Common.Loggers;
using FruitBankHybrid.Shared.Services.SignalRs;
using Mango.Nop.Core.Dtos;

namespace FruitBankHybrid.Shared.Tests
{
    [TestClass]
    public sealed class FruitBankClientTests
    {
        private FruitBankSignalRClient _signalRClient = null!;

        [TestInitialize]
        public void TestInit()
        {
            _signalRClient = new FruitBankSignalRClient(new List<IAcLogWriterClientBase>
            {
                //new ConsoleLogWriter(AppType.TestUnit, LogLevel.Detail, nameof(FruitBankClientTests)),
                new SignaRClientLogItemWriter(AppType.TestUnit, LogLevel.Detail, nameof(FruitBankClientTests))
            });
        }

        #region Partner

        [TestMethod]
        public async Task GetPartnersTest()
        {
            var partners = await _signalRClient.GetPartners();

            Assert.IsNotNull(partners);
            Assert.IsTrue(partners.Any());
        }

        //[DataTestMethod]
        //[DataRow(1)]
        public async Task<Partner> GetPartnerByIdTest(int partnerId)
        {
            var partner = await _signalRClient.GetPartnerById(partnerId);

            Assert.IsNotNull(partner);
            Assert.IsTrue(partner.Id == partnerId);

            return partner;
        }

        [DataTestMethod]
        [DataRow(2)]
        public async Task UpdatePartnerTest(int partnerId)
        {
            var partner = await GetPartnerByIdTest(partnerId);

            const string fixture = "_test.temp";
            var newName = $"{partner.Name.Replace(fixture, string.Empty)}{fixture}";

            partner.Name = newName;
            await _signalRClient.UpdatePartner(partner);

            partner = await GetPartnerByIdTest(partnerId);
            Assert.IsTrue(partner.Name == newName);

            partner.Name = partner.Name.Replace(fixture, string.Empty);
            await _signalRClient.UpdatePartner(partner);
        }

        #endregion Partner

        #region Shipping

        [TestMethod]
        public async Task GetShippingsTest()
        {
            var shippings = await _signalRClient.GetShippings();

            Assert.IsNotNull(shippings);
            Assert.IsTrue(shippings.Any());
        }

        [TestMethod]
        public async Task GetShippingByIdTest()
        {
            var shipping = await _signalRClient.GetShippingById(1);

            Assert.IsNotNull(shipping);
            Assert.IsTrue(shipping.Id == 1);
        }

        #endregion Shipping

        #region ShippingItem

        [TestMethod]
        public async Task GetShippingItemsTest()
        {
            var shippingItems = await _signalRClient.GetShippingItems();

            Assert.IsNotNull(shippingItems);
            Assert.IsTrue(shippingItems.Any());
        }

        [TestMethod]
        public async Task GetShippingItemByIdTest()
        {
            var shippingItem = await _signalRClient.GetShippingItemById(1);

            Assert.IsNotNull(shippingItem);
            Assert.IsTrue(shippingItem.Id == 1);
        }

        #endregion ShippingItem

        #region ShippingDocument

        [TestMethod]
        public async Task GetShippingDocumentsTest()
        {
            var shippingDocuments = await _signalRClient.GetShippingDocuments();

            Assert.IsNotNull(shippingDocuments);
            Assert.IsTrue(shippingDocuments.Any());
        }

        [TestMethod]
        public async Task GetShippingDocumentByIdTest()
        {
            var shippingDocument = await _signalRClient.GetShippingDocumentById(1);

            Assert.IsNotNull(shippingDocument);
            Assert.IsTrue(shippingDocument.Id == 1);
        }

        #endregion ShippingDocument

        #region Customer

        [TestMethod]
        public async Task GetMeasuringUsersTest()
        {
            var users = await _signalRClient.GetMeasuringUsers();

            Assert.IsNotNull(users);
            Assert.IsTrue(users.Any());
            Assert.IsTrue(users.All(x => !x.Email.IsNullOrEmpty() && !x.Deleted));
        }

        #endregion Customer

        #region Product

        [TestMethod]
        public async Task GetProductDtosTest()
        {
            var productDto = await _signalRClient.GetProductDtos();

            Assert.IsNotNull(productDto);
            Assert.IsTrue(productDto.Any());
            Assert.IsTrue(productDto.All(x => !x.Name.IsNullOrEmpty() && !x.Deleted));
        }

        #endregion Product

        [TestMethod]
        [DataRow("aasd@dsserver.com", "Asdasd123456")]
        public async Task LoginMeasuringUserTest_TrueIfHasCustomerDto(string email, string password)
        {
            var loginModelResponse = await _signalRClient.LoginMeasuringUser(email, password);

            Assert.IsNotNull(loginModelResponse);
            Assert.IsNotNull(loginModelResponse.CustomerDto, loginModelResponse.ErrorMessage);

            Assert.IsTrue(loginModelResponse.CustomerDto.Email == email, loginModelResponse.ErrorMessage);
        }

        [TestMethod]
        [DataRow("adam.g@aycode.com", "123")]
        public async Task LoginMeasuringUserTest_TrueIfHasNotCustomerDto(string email, string password)
        {
            var loginModelResponse = await _signalRClient.LoginMeasuringUser(email, password);

            Assert.IsNotNull(loginModelResponse);
            Assert.IsNull(loginModelResponse.CustomerDto);

            Assert.IsFalse(loginModelResponse.ErrorMessage.IsNullOrWhiteSpace());
            Console.WriteLine($"Succes: {loginModelResponse.ErrorMessage}");
        }
    }
}