420 lines
16 KiB
C#
420 lines
16 KiB
C#
using AyCode.Core.Enums;
|
|
using AyCode.Core.Loggers;
|
|
using AyCode.Utils.Extensions;
|
|
using FruitBank.Common;
|
|
using FruitBank.Common.Dtos;
|
|
using FruitBank.Common.Entities;
|
|
using FruitBank.Common.Interfaces;
|
|
using FruitBank.Common.Loggers;
|
|
using FruitBankHybrid.Shared.Services.SignalRs;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.InteropServices.JavaScript;
|
|
// ReSharper disable CompareOfFloatsByEqualityOperator
|
|
|
|
namespace FruitBankHybrid.Shared.Tests
|
|
{
|
|
[TestClass]
|
|
public sealed class FruitBankClientTests
|
|
{
|
|
private const int CustomerIdAasdDsserverCom = 6;//aasd@dsserver.com
|
|
private const string Fixture = "_test.temp";
|
|
|
|
private FruitBankSignalRClient _signalRClient = null!;
|
|
|
|
private static string GetFixtureName(string name) => $"{GetOriginalName(name)}{Fixture}";
|
|
private static string GetOriginalName(string name) => name.Replace(Fixture, string.Empty);
|
|
|
|
[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.Count != 0);
|
|
}
|
|
|
|
//[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);
|
|
|
|
var newName = GetFixtureName(partner.Name);
|
|
|
|
partner.Name = newName;
|
|
partner = await _signalRClient.UpdatePartner(partner);
|
|
|
|
Assert.IsNotNull(partner);
|
|
Assert.IsTrue(partner.Name == newName);
|
|
|
|
partner.Name = GetOriginalName(partner.Name);
|
|
partner = await _signalRClient.UpdatePartner(partner);
|
|
|
|
Assert.IsNotNull(partner);
|
|
Assert.IsTrue(partner.Id == partnerId);
|
|
}
|
|
#endregion Partner
|
|
|
|
#region Shipping
|
|
[TestMethod]
|
|
public async Task GetShippingsTest()
|
|
{
|
|
var shippings = await _signalRClient.GetShippings();
|
|
|
|
Assert.IsNotNull(shippings);
|
|
Assert.IsTrue(shippings.Count != 0);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task GetNotMeasuredShippingsTest()
|
|
{
|
|
var shippings = await _signalRClient.GetNotMeasuredShippings();
|
|
|
|
Assert.IsNotNull(shippings);
|
|
var ShippingMeasuredDateAddDay = 1000; //dfd
|
|
Assert.IsTrue(shippings.All(s => !s.IsAllMeasured || s.MeasuredDate != null || s.MeasuredDate < DateTime.Now.AddDays(ShippingMeasuredDateAddDay)));
|
|
}
|
|
|
|
//[TestMethod]
|
|
//[DataRow(1)]
|
|
public async Task<Shipping> GetShippingByIdTest(int shippingId)
|
|
{
|
|
var shipping = await _signalRClient.GetShippingById(shippingId);
|
|
|
|
Assert.IsNotNull(shipping);
|
|
Assert.IsNotNull(shipping.ShippingDocuments);
|
|
|
|
Assert.IsTrue(shipping.Id == shippingId);
|
|
Assert.IsTrue(shipping.ShippingDocuments.All(s => s.ShippingId == shippingId));
|
|
Assert.IsTrue(shipping.ShippingDocuments.All(sd => sd.ShippingItems != null && sd.ShippingItems.Any(si => si.ShippingDocumentId == sd.Id)));
|
|
|
|
return shipping;
|
|
}
|
|
|
|
[DataTestMethod]
|
|
[DataRow(1)]
|
|
public async Task UpdateShippingTest(int shippingId)
|
|
{
|
|
var shipping = await GetShippingByIdTest(shippingId);
|
|
var newLicencePlate = GetFixtureName(shipping.LicencePlate);
|
|
|
|
shipping.LicencePlate = newLicencePlate;
|
|
await _signalRClient.UpdateShipping(shipping);
|
|
|
|
shipping = await GetShippingByIdTest(shippingId);
|
|
|
|
Assert.IsTrue(shipping.Id == shippingId);
|
|
Assert.IsTrue(shipping.LicencePlate == newLicencePlate);
|
|
|
|
shipping.LicencePlate = GetOriginalName(shipping.LicencePlate);
|
|
await _signalRClient.UpdateShipping(shipping);
|
|
|
|
Assert.IsTrue(shipping.Id == shippingId);
|
|
}
|
|
|
|
#endregion Shipping
|
|
|
|
#region ShippingItem
|
|
|
|
[TestMethod]
|
|
public async Task GetShippingItemsTest()
|
|
{
|
|
var shippingItems = await _signalRClient.GetShippingItems();
|
|
|
|
Assert.IsNotNull(shippingItems);
|
|
Assert.IsTrue(shippingItems.Count != 0);
|
|
|
|
Assert.IsTrue(shippingItems.All(si=>si.Product?.Id == si.ProductId), "shippingItem.Product == null");
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(1, true)]
|
|
[DataRow(2, true)]
|
|
[DataRow(3, false)]
|
|
[DataRow(4, false)]
|
|
public async Task GetShippingItemByIdTest(int shippingItemId, bool shippingDocumentFileExcepted)
|
|
{
|
|
var shippingItem = await GetShippingItemByIdAsync(shippingItemId);
|
|
|
|
if (shippingDocumentFileExcepted) Assert.IsTrue(shippingItem.ShippingDocument?.ShippingDocumentToFiles?.FirstOrDefault()?.ShippingDocumentFile?.Id == 1);
|
|
else
|
|
{
|
|
Assert.IsNotNull(shippingItem.ShippingDocument);
|
|
Assert.IsTrue(shippingItem.ShippingDocument.ShippingDocumentToFiles?.Count == 0);
|
|
}
|
|
}
|
|
|
|
[return: NotNull]
|
|
public async Task<ShippingItem> GetShippingItemByIdAsync(int shippingItemId)
|
|
{
|
|
var shippingItem = await _signalRClient.GetShippingItemById(shippingItemId);
|
|
|
|
Assert.IsNotNull(shippingItem);
|
|
Assert.IsNotNull(shippingItem.Product, $"shippingItem.Product == null; shippingItem.Id: {shippingItem.ProductId}");
|
|
Assert.IsTrue(shippingItem.Id == shippingItemId);
|
|
|
|
Assert.IsTrue(shippingItem.QuantityOnDocument > 0, "QuantityOnDocument == 0");
|
|
Assert.IsTrue(shippingItem.NetWeightOnDocument > 0, "NetWeightOnDocument == 0");
|
|
Assert.IsTrue(shippingItem.GrossWeightOnDocument > 0, "GrossWeightOnDocument == 0");
|
|
|
|
return shippingItem;
|
|
}
|
|
|
|
[DataTestMethod]
|
|
[DataRow(1, -1, -2.137563300001, -3.75238200001)]
|
|
[DataRow(1, 1, 2.137563300001, 3.75238200001)]
|
|
[DataRow(2, -1, -2.137563300001, 3.75238200001)]
|
|
[DataRow(3, 1, 2.137563300001, -3.75238200001)]
|
|
[DataRow(3, 1, 2.137563300001, 3.75238200001)]
|
|
[DataRow(4, -1, 2.137563300001, 3.75238200001)]
|
|
[DataRow(5, 1, 2.137563300001, 3.75238200001)]
|
|
public async Task UpdateShippingItemTest(int shippingItemId, int incQuantity, double incNetWeight, double incGrossWeight)
|
|
{
|
|
var originalShippingItem = await GetShippingItemByIdAsync(shippingItemId);
|
|
var originalMeasuringProductDto = await GetMeasuringProductDtoByIdAsync(originalShippingItem.ProductId!.Value, originalShippingItem.IsMeasurable);
|
|
|
|
Assert.IsTrue(originalShippingItem.IsMeasurable == originalMeasuringProductDto.IsMeasurable);
|
|
|
|
var shippingItem = await GetShippingItemByIdAsync(shippingItemId);
|
|
|
|
var shippingItemPallet = shippingItem.ShippingItemPallets!.FirstOrDefault();
|
|
|
|
if (shippingItemPallet == null)
|
|
{
|
|
shippingItemPallet = new ShippingItemPallet { ShippingItemId = shippingItem.Id/*, PalletSize = shippingItem.PalletSize*/ };
|
|
shippingItem.ShippingItemPallets!.Add(shippingItemPallet);
|
|
}
|
|
|
|
Assert.IsNotNull(shippingItemPallet);
|
|
|
|
shippingItemPallet.Quantity += incQuantity;
|
|
shippingItemPallet.NetWeight += incNetWeight;
|
|
shippingItemPallet.GrossWeight += incGrossWeight;
|
|
|
|
shippingItem = await _signalRClient.UpdateShippingItem(shippingItem);
|
|
|
|
if (!shippingItemPallet.IsValidMeasuringValues(originalMeasuringProductDto.IsMeasurable))
|
|
{
|
|
Assert.IsNull(shippingItem);
|
|
return;
|
|
}
|
|
|
|
Assert.IsNotNull(shippingItem);
|
|
Assert.IsNotNull(shippingItem.Product);
|
|
|
|
//incNetWeight = double.Round(incNetWeight, 1);
|
|
//incGrossWeight = double.Round(incGrossWeight, 1);
|
|
|
|
Assert.IsTrue(shippingItem.IsMeasured);
|
|
Assert.IsTrue(shippingItem.Product.StockQuantity == originalShippingItem.Product!.StockQuantity + incQuantity);
|
|
|
|
Assert.IsTrue(shippingItem.IsMeasurable == originalMeasuringProductDto.IsMeasurable);
|
|
Assert.IsTrue(shippingItem.MeasuredQuantity == originalShippingItem.MeasuredQuantity + incQuantity);
|
|
|
|
|
|
var measuringProductDto = await GetMeasuringProductDtoByIdAsync(originalShippingItem.ProductId!.Value, shippingItem.IsMeasurable);
|
|
|
|
Assert.IsTrue(measuringProductDto.StockQuantity == originalMeasuringProductDto.StockQuantity + incQuantity);
|
|
|
|
Assert.IsTrue(shippingItem.MeasuredNetWeight == double.Round(originalShippingItem.MeasuredNetWeight + (shippingItem.IsMeasurable ? incNetWeight : 0), 1));
|
|
Assert.IsTrue(shippingItem.MeasuredGrossWeight == double.Round(originalShippingItem.MeasuredGrossWeight + (shippingItem.IsMeasurable ? incGrossWeight : 0), 1));
|
|
|
|
Assert.IsTrue(measuringProductDto.NetWeight == double.Round(originalMeasuringProductDto.NetWeight + (shippingItem.IsMeasurable ? incNetWeight : 0), 1));
|
|
Assert.IsTrue(measuringProductDto.GrossWeight == double.Round(originalMeasuringProductDto.GrossWeight + (shippingItem.IsMeasurable ? incGrossWeight : 0), 1));
|
|
}
|
|
|
|
#endregion ShippingItem
|
|
|
|
#region ShippingDocument
|
|
|
|
[TestMethod]
|
|
public async Task GetShippingDocumentsTest()
|
|
{
|
|
var shippingDocuments = await _signalRClient.GetShippingDocuments();
|
|
|
|
Assert.IsNotNull(shippingDocuments);
|
|
Assert.IsTrue(shippingDocuments.Count != 0);
|
|
Assert.IsTrue(shippingDocuments.Any(x => x.ShippingDocumentToFiles?.Count > 0));
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(2, true)]
|
|
[DataRow(3, false)]
|
|
[DataRow(4, false)]
|
|
public async Task GetShippingDocumentByIdTest(int shippingDocumentId, bool shippingDocumentFileExcepted)
|
|
{
|
|
var shippingDocument = await GetShippingDocumentByIdAsync(shippingDocumentId);
|
|
|
|
if (shippingDocumentFileExcepted) Assert.IsTrue(shippingDocument.ShippingDocumentToFiles?.FirstOrDefault()?.ShippingDocumentFile?.Id == 1);
|
|
else
|
|
{
|
|
Assert.IsTrue(shippingDocument.ShippingDocumentToFiles?.Count == 0);
|
|
}
|
|
}
|
|
|
|
[return: NotNull]
|
|
public async Task<ShippingDocument> GetShippingDocumentByIdAsync(int shippingDocumentId)
|
|
{
|
|
var shippingDocument = await _signalRClient.GetShippingDocumentById(shippingDocumentId);
|
|
|
|
Assert.IsNotNull(shippingDocument);
|
|
Assert.IsTrue(shippingDocument.Id == shippingDocumentId);
|
|
|
|
return shippingDocument;
|
|
}
|
|
|
|
[DataTestMethod]
|
|
[DataRow(2)]
|
|
public async Task UpdateShippingDocumentTest(int shippingDocumentId)
|
|
{
|
|
var shippingDocument = await GetShippingDocumentByIdAsync(shippingDocumentId);
|
|
var newCountry = GetFixtureName(shippingDocument.Country);
|
|
|
|
shippingDocument.Country = newCountry;
|
|
await _signalRClient.UpdateShippingDocument(shippingDocument);
|
|
|
|
shippingDocument = await GetShippingDocumentByIdAsync(shippingDocumentId);
|
|
|
|
Assert.IsTrue(shippingDocument.Country == newCountry);
|
|
Assert.IsTrue(shippingDocument!.ShippingDocumentToFiles?.FirstOrDefault()?.ShippingDocumentFile?.Id == 1);
|
|
|
|
shippingDocument.Country = GetOriginalName(shippingDocument.Country);
|
|
await _signalRClient.UpdateShippingDocument(shippingDocument);
|
|
}
|
|
|
|
#endregion ShippingDocument
|
|
|
|
#region Customer
|
|
|
|
[TestMethod]
|
|
public async Task GetMeasuringUsersTest()
|
|
{
|
|
var users = await _signalRClient.GetMeasuringUsers();
|
|
|
|
Assert.IsNotNull(users);
|
|
Assert.IsTrue(users.Count != 0);
|
|
Assert.IsTrue(users.All(x => !x.Email.IsNullOrEmpty() && !x.Deleted));
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(CustomerIdAasdDsserverCom)]
|
|
public async Task GetCustomerRolesByCustomerIdTest(int customerId)
|
|
{
|
|
var customerRoles = await _signalRClient.GetCustomerRolesByCustomerId(customerId);
|
|
|
|
Assert.IsNotNull(customerRoles);
|
|
Assert.IsTrue(customerRoles.Count > 0);
|
|
Assert.IsTrue(customerRoles.Any(cr => cr.SystemName == "Measuring"));
|
|
}
|
|
|
|
#endregion Customer
|
|
|
|
#region Product
|
|
|
|
[TestMethod]
|
|
public async Task GetProductDtosTest()
|
|
{
|
|
var productDto = await _signalRClient.GetProductDtos();
|
|
|
|
Assert.IsNotNull(productDto);
|
|
Assert.IsTrue(productDto.Count != 0);
|
|
Assert.IsTrue(productDto.All(x => !x.Name.IsNullOrEmpty() && !x.Deleted));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task GetAllMeasuringProductDtosTest()
|
|
{
|
|
var measuringProductDtos = await _signalRClient.GetAllMeasuringProductDtos();
|
|
|
|
Assert.IsNotNull(measuringProductDtos);
|
|
Assert.IsTrue(measuringProductDtos.Count != 0);
|
|
|
|
Assert.IsTrue(measuringProductDtos.All(x => !x.Name.IsNullOrEmpty() && !x.Deleted));
|
|
Assert.IsTrue(measuringProductDtos.All(x => !x.IsMeasurable || x.HasMeasuringValues()));
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(1, true)]
|
|
[DataRow(5, true)]
|
|
[DataRow(6, false)]
|
|
[DataRow(33, true)]
|
|
public async Task GetMeasuringProductDtoByIdTest(int productId, bool isMeasurableExcepted)
|
|
{
|
|
await GetMeasuringProductDtoByIdAsync(productId, isMeasurableExcepted);
|
|
}
|
|
|
|
public async Task<MeasuringProductDto> GetMeasuringProductDtoByIdAsync(int productId, bool isMeasurableExcepted)
|
|
{
|
|
var measuringProductDto = await _signalRClient.GetMeasuringProductDtoById(productId);
|
|
|
|
Assert.IsNotNull(measuringProductDto);
|
|
|
|
if (isMeasurableExcepted) Assert.IsTrue(measuringProductDto.HasMeasuringValues(), $"{measuringProductDto.IsMeasurable}, {measuringProductDto.NetWeight}, {measuringProductDto.GrossWeight}");
|
|
else
|
|
{
|
|
Assert.IsTrue(measuringProductDto.Id > 0);
|
|
Assert.IsTrue(measuringProductDto.StockQuantity > 0);
|
|
Assert.IsTrue(measuringProductDto.NetWeight == 0);
|
|
Assert.IsTrue(measuringProductDto.GrossWeight == 0);
|
|
|
|
Assert.IsFalse(measuringProductDto.IsMeasurable);
|
|
}
|
|
|
|
return measuringProductDto;
|
|
}
|
|
|
|
#endregion Product
|
|
|
|
#region Login
|
|
[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}");
|
|
}
|
|
#endregion Login
|
|
}
|
|
}
|