NTP_V2/tests/NTP.Tests/Refinery/TripActionServiceTests.cs

374 lines
21 KiB
C#

using NTP.Application.Abstractions;
using NTP.Application.Common;
using NTP.Application.Refinery.Integrations;
using NTP.Application.Refinery.RemainingBalance;
using NTP.Application.Refinery.Trips;
namespace NTP.Tests.Refinery;
/// <summary>The action service against in-memory fakes: card arithmetic, status rules, what is (not) written when Dinarak refuses.</summary>
public class TripActionServiceTests
{
private sealed class FakeTrips : ITripRepository
{
public TripRecord Trip { get; set; } = new() { Id = 1, Pn = "633472", Tn = "6021151", StatusCode = "RESD", CurrentBalance = 100m, LoadingDate = new DateTime(2023, 8, 2), NetLoadingWeight = 34560, NetDischargeWeight = 34290, DischargeAuthNo = "26968", OwnerName = "Owner" };
public CardInfo? Card { get; set; } = new(7, 100m);
public decimal? Diesel { get; set; } = 250m;
public decimal? LastCardLogAmount { get; set; } = 150m;
public TripWallet? Wallet { get; set; }
public List<string> Calls { get; } = [];
public List<(string Method, string Old, string New)> Logs { get; } = [];
public List<(string Method, decimal Before, decimal After, decimal Amount)> CardLogs { get; } = [];
public decimal? CardBalanceSet { get; private set; }
public int? ReversedTo { get; private set; }
public Task<TripRecord?> GetAsync(long id, CancellationToken ct = default) => Task.FromResult<TripRecord?>(Trip);
public Task<TripLock?> LockAsync(long id, CancellationToken ct = default) { Calls.Add("lock"); return Task.FromResult<TripLock?>(new(Trip.StatusCode, Trip.DieselCharge)); }
public Task<TripWallet?> GetActiveWalletByTruckAsync(string tn, CancellationToken ct = default) => Task.FromResult(Wallet);
public Task<TripWallet?> GetWalletAsync(long walletId, CancellationToken ct = default) => Task.FromResult(Wallet);
public Task<bool> GetAuditModeAsync(CancellationToken ct = default) => Task.FromResult(false);
public Task<decimal?> GetFirstPaymentValueAsync(CancellationToken ct = default) => Task.FromResult<decimal?>(100m);
public Task<IReadOnlyList<KeyValuePair<string, string?>>> GetVariablesAsync(DateTime loadingDate, CancellationToken ct = default) =>
Task.FromResult<IReadOnlyList<KeyValuePair<string, string?>>>(
[
new("COMMISSION", "0.95"), new("DIESEL_LITER_PRICE", "0.715"), new("DRIVER_TIP", "20"), new("FIRST_ADVANCE_PAYMENT", "100"),
new("PERMIT_DISPATCH", "2.5"), new("TOLERANCE_PERCENTAGE", "0.005"), new("TON_PRICE", "700"), new("TON_WAGE", "17.936"), new("WAYBILL_FEE", "0.75")
]);
public Task<int?> GetWaterFlagAsync(long id, CancellationToken ct = default) => Task.FromResult<int?>(null);
public Task<decimal?> CalculateDieselAsync(long id, CancellationToken ct = default) => Task.FromResult(Diesel);
public Task<decimal?> CalculateAmountAsync(long id, CancellationToken ct = default) => Task.FromResult<decimal?>(271.975m);
public Task<bool> HasTransferLogAsync(long id, CancellationToken ct = default) => Task.FromResult(true);
public Task<IReadOnlyList<TripRecord>> GetTripsOfPeriodAsync(DateTime from, DateTime to, CancellationToken ct = default) => Task.FromResult<IReadOnlyList<TripRecord>>([]);
public Task<CardInfo?> GetActiveCardAsync(string tn, CancellationToken ct = default) => Task.FromResult(Card);
public Task<decimal?> GetLastCardLogAmountAsync(string pn, string methodName, CancellationToken ct = default) => Task.FromResult(LastCardLogAmount);
public Task InsertCardLogAsync(long cardId, string methodName, decimal before, decimal after, decimal amount, string userId, string pn, CancellationToken ct = default)
{ CardLogs.Add((methodName, before, after, amount)); return Task.CompletedTask; }
public Task UpdateCardBalanceAsync(long cardId, decimal balance, string userId, long tripId, CancellationToken ct = default) { CardBalanceSet = balance; return Task.CompletedTask; }
public Task MarkFirstAdvanceAsync(long id, string userId, CancellationToken ct = default) { Calls.Add("first"); return Task.CompletedTask; }
public Task MarkSecondAdvanceAsync(long id, string userId, decimal secondPaymentValue, CancellationToken ct = default) { Calls.Add("second:" + secondPaymentValue); return Task.CompletedTask; }
public Task MarkAdvanceReversedAsync(long id, string userId, int dieselCharge, CancellationToken ct = default) { ReversedTo = dieselCharge; return Task.CompletedTask; }
public Task SaveAmountsAsync(long id, string userId, TripAmounts amounts, CancellationToken ct = default) { Calls.Add("amounts:" + amounts.NetWage); return Task.CompletedTask; }
public Task SetStatusReceivedAsync(long id, string userId, string status, CancellationToken ct = default) { Calls.Add("status:" + status); return Task.CompletedTask; }
public Task MarkExchangedAsync(long id, string userId, string? remarks, string? paymentOptions, bool setReceived, long? walletId, CancellationToken ct = default) { Calls.Add($"exchanged:{paymentOptions}:{setReceived}:{walletId}"); return Task.CompletedTask; }
public Task<decimal> BumpDinarakReferenceAsync(long id, string userId, CancellationToken ct = default) { Calls.Add("bump"); return Task.FromResult(352.11m); }
public Task SetVoucherSerialAsync(long id, long serial, CancellationToken ct = default) { Calls.Add("serial:" + serial); return Task.CompletedTask; }
public Task ConfirmExchangeAsync(long id, string userId, CancellationToken ct = default) { Calls.Add("confirm"); return Task.CompletedTask; }
public Task InsertLogAsync(long tripId, string methodName, string userId, string oldJson, string newJson, CancellationToken ct = default)
{ Logs.Add((methodName, oldJson, newJson)); return Task.CompletedTask; }
public Task<PagedResult<TripLogRow>> SearchLogAsync(long tripId, PageRequest page, CancellationToken ct = default) => throw new NotSupportedException();
public Task<PagedResult<TripRow>> SearchAsync(TripQuery query, PageRequest page, CancellationToken ct = default) => throw new NotSupportedException();
public Task<IReadOnlyList<TripReportRow>> ReportAsync(TripQuery query, CancellationToken ct = default) => throw new NotSupportedException();
public Task<IReadOnlyList<DieselReportRow>> DieselReportAsync(DieselReportQuery query, CancellationToken ct = default) => throw new NotSupportedException();
public Task<IReadOnlyList<CardRow>> CardsAsync(string? tn, CancellationToken ct = default) => throw new NotSupportedException();
public Task<IReadOnlyList<TripReportRow>> BankReportAsync(BankReportQuery query, CancellationToken ct = default) => throw new NotSupportedException();
}
private sealed class FakeBalances(List<string> calls) : IRemainingBalanceService
{
public Task<decimal?> GetAsync(string tn, CancellationToken ct = default) => Task.FromResult<decimal?>(null);
public Task ResetAfterPaymentAsync(string tn, long tripId, CancellationToken ct = default) { calls.Add("reset-balance"); return Task.CompletedTask; }
public Task AddAsync(string tn, decimal delta, long tripId, long variableGroupId, CancellationToken ct = default) => Task.CompletedTask;
public Task<TripsResult> RecalculateForPeriodAsync(DateTime startDate, DateTime endDate, long variableGroupId, CancellationToken ct = default) => throw new NotSupportedException();
}
private sealed class FakeAmounts : ITripAmountsService
{
public Task<TripAmounts> ComputeAsync(TripRecord trip, CancellationToken ct) =>
Task.FromResult(TripCalculator.Calculate(new TripWeights(trip.NetLoadingWeight ?? 0, trip.NetDischargeWeight ?? 0, 0, null),
TripVariables.FromPairs([new("TON_WAGE", "17.936"), new("TON_PRICE", "700"), new("TOLERANCE_PERCENTAGE", "0.005"), new("DRIVER_TIP", "20"),
new("PERMIT_DISPATCH", "2.5"), new("WAYBILL_FEE", "0.75"), new("COMMISSION", "0.95"), new("DIESEL_LITER_PRICE", "0.715"), new("FIRST_ADVANCE_PAYMENT", "100")]), null));
}
private sealed class FakeDinarak(DinarakTransferResult result, DinarakTransferStatus? status = null) : IDinarakGateway, IDinarakReferenceGateway
{
public int Transfers { get; private set; }
public (string Wallet, decimal Amount)? Last { get; private set; }
public Task<DinarakTransferResult> TransferAsync(long tripId, string walletNumber, string nnpn, decimal amount, string receiverName, CancellationToken ct = default)
{ Transfers++; Last = (walletNumber, amount); return Task.FromResult(result); }
public Task<DinarakTransferStatus> GetTransferByMessageIdAsync(long messageId, CancellationToken ct = default) => Task.FromResult(status ?? new(false, "Failed", null));
public Task<DinarakTransferStatus> GetTransferByReferenceAsync(decimal reference, CancellationToken ct = default) => Task.FromResult(status ?? new(false, "Failed", null));
}
private sealed class FakeVoucher : IVoucherSerialRepository { public Task<long> NextAsync(CancellationToken ct = default) => Task.FromResult(202600096L); }
private sealed class FakeUow : IUnitOfWork
{
public int Committed { get; private set; }
public int RolledBack { get; private set; }
public Task BeginAsync(CancellationToken ct = default) => Task.CompletedTask;
public Task CommitAsync(CancellationToken ct = default) { Committed++; return Task.CompletedTask; }
public Task RollbackAsync(CancellationToken ct = default) { RolledBack++; return Task.CompletedTask; }
public async Task<T> ExecuteInTransactionAsync<T>(Func<CancellationToken, Task<T>> work, CancellationToken ct = default)
{
try { var r = await work(ct); Committed++; return r; }
catch { RolledBack++; throw; }
}
}
private sealed class FakeUser : ICurrentUser
{
public bool IsAuthenticated => true; public long Id => 16190811; public string UserId => "REF_X"; public string Name => "x"; public string RoleCode => "REFINERY_MGR";
public string RoleName => ""; public string Domain => "ASEZA"; public long? LocationId => null; public string LocationName => ""; public long? StkId => null;
public long? CompId => null; public long? CompanyId => null; public string CompanyName => ""; public string CompanyCode => ""; public string EmpNo => "";
public string Lang => "AR"; public bool IsStaff => false;
public bool IsInRole(string roleCode) => false; public bool IsInAnyRole(params string[] roleCodes) => false;
}
private sealed class FakeSettings : ITripSettingsService { public TripOptions Value { get; } = new(); }
private static (TripActionService Svc, FakeTrips Trips, FakeUow Uow, FakeDinarak Dinarak) Build(FakeDinarak? dinarak = null)
{
var trips = new FakeTrips();
var uow = new FakeUow();
var d = dinarak ?? new FakeDinarak(new("000", "SUCCESS"));
var svc = new TripActionService(trips, new FakeAmounts(), new FakeBalances(trips.Calls), d, d, new FakeVoucher(), uow, new FakeUser(), new FakeSettings());
return (svc, trips, uow, d);
}
private static TripWallet ReadyWallet() => new() { Id = 5, Epayment = 1, WalletNumber = "795000000", OwnerNnpn = 9871012345, OwnerName = "Owner" };
// ---------------------------------------------------------------- diesel advances
[Fact]
public async Task First_advance_logs_the_card_movement_and_sets_the_card_to_the_calculated_value()
{
var (svc, trips, _, _) = Build();
var r = await svc.FirstAdvanceAsync(1, default);
Assert.Equal("تمت العملية بنجاح", r.Message);
var log = Assert.Single(trips.CardLogs);
Assert.Equal(("FIRST_ADVANCED_PAYMENT", 100m, 250m, 150m), log);
Assert.Equal(250m, trips.CardBalanceSet);
Assert.Contains("first", trips.Calls);
var tripLog = Assert.Single(trips.Logs);
Assert.Equal("FIRST_ADVANCED_PAYMENT", tripLog.Method);
Assert.Equal("{\"CURRENT_BALANCE\":\"250\"}", tripLog.New);
}
[Fact]
public async Task First_advance_twice_is_refused_with_the_legacy_text_and_writes_nothing()
{
var (svc, trips, uow, _) = Build();
trips.Trip.DieselCharge = 1;
var ex = await Assert.ThrowsAsync<BusinessException>(() => svc.FirstAdvanceAsync(1, default));
Assert.Equal("تم اجراء دفعة الديزل الاولى مسبقاً", ex.Message);
Assert.Empty(trips.CardLogs);
Assert.Equal(1, uow.RolledBack);
}
[Fact]
public async Task Advance_without_an_active_card_is_refused()
{
var (svc, trips, _, _) = Build();
trips.Card = null;
var ex = await Assert.ThrowsAsync<BusinessException>(() => svc.FirstAdvanceAsync(1, default));
Assert.Equal("بطاقة تعبئة الديزل غير معرفة", ex.Message);
}
[Fact]
public async Task Second_advance_needs_the_first_and_stores_the_calculated_value()
{
var (svc, trips, _, _) = Build();
await Assert.ThrowsAsync<BusinessException>(() => svc.SecondAdvanceAsync(1, default)); // DieselCharge 0
trips.Trip.DieselCharge = 1;
trips.Trip.StatusCode = "LOADED";
await svc.SecondAdvanceAsync(1, default);
Assert.Contains("second:250", trips.Calls);
Assert.Equal("SECOND_ADVANCED_PAYMENT", trips.CardLogs[0].Method);
}
[Fact]
public async Task First_advance_reverse_takes_back_the_logged_amount()
{
var (svc, trips, _, _) = Build();
trips.Trip.DieselCharge = 1;
trips.Card = new CardInfo(7, 250m);
await svc.FirstAdvanceReverseAsync(1, default);
Assert.Equal(("FIRST_ADVANCED_PAYMENT_REVERSE", 250m, 100m, -150m), trips.CardLogs[0]);
Assert.Equal(100m, trips.CardBalanceSet);
Assert.Equal(0, trips.ReversedTo);
}
[Fact]
public async Task Second_advance_reverse_goes_back_to_step_one()
{
var (svc, trips, _, _) = Build();
trips.Trip.DieselCharge = 2;
trips.Card = new CardInfo(7, 450m);
trips.LastCardLogAmount = 200m;
await svc.SecondAdvanceReverseAsync(1, default);
Assert.Equal(("SECOND_ADVANCED_PAYMENT_REVERSE", 450m, 250m, -200m), trips.CardLogs[0]);
Assert.Equal(1, trips.ReversedTo);
}
[Theory]
[InlineData(0, "FIRST_ADVANCED_PAYMENT_REVERSE_IS_EXIST")]
[InlineData(2, "CANNOT_FIRST_ADVANCED_PAYMENT_REVERSE")]
public async Task First_advance_reverse_checks_the_step(int step, string code)
{
var (svc, trips, _, _) = Build();
trips.Trip.DieselCharge = step;
var ex = await Assert.ThrowsAsync<BusinessException>(() => svc.FirstAdvanceReverseAsync(1, default));
Assert.Equal(code, ex.Code);
}
// ---------------------------------------------------------------- payment
[Fact]
public async Task Exchange_pays_through_dinarak_then_marks_the_trip_and_resets_the_balance()
{
var (svc, trips, _, dinarak) = Build();
trips.Trip.StatusCode = "DISCHARGED";
trips.Wallet = ReadyWallet();
await svc.ExchangeAsync(1, default);
Assert.Equal(1, dinarak.Transfers);
Assert.Equal(("795000000", 271.975m), dinarak.Last);
Assert.Contains("exchanged::True:5", trips.Calls);
Assert.Contains("reset-balance", trips.Calls);
Assert.Equal("EXCHANGE", trips.Logs.Single().Method);
Assert.Contains("تم الصرف", trips.Logs.Single().New);
}
[Fact]
public async Task Exchange_refused_by_dinarak_keeps_the_trip_and_logs_the_remark()
{
var (svc, trips, _, _) = Build(new FakeDinarak(new("102", "Insufficient_funds")));
trips.Trip.StatusCode = "DISCHARGED";
trips.Wallet = ReadyWallet();
var ex = await Assert.ThrowsAsync<BusinessException>(() => svc.ExchangeAsync(1, default));
Assert.Contains("INSUFFICIENT_FUNDS", ex.Message);
Assert.DoesNotContain(trips.Calls, c => c.StartsWith("exchanged"));
Assert.DoesNotContain("reset-balance", trips.Calls);
Assert.Contains("Insufficient_funds", trips.Logs.Single().New);
}
[Fact]
public async Task Exchange_with_the_integration_off_says_so()
{
var (svc, trips, _, _) = Build(new FakeDinarak(new("106", "DINARAK_DISABLED")));
trips.Trip.StatusCode = "DISCHARGED";
trips.Wallet = ReadyWallet();
var ex = await Assert.ThrowsAsync<BusinessException>(() => svc.ExchangeAsync(1, default));
Assert.Equal("DINARAK_DISABLED", ex.Code);
}
[Fact]
public async Task Exchange_stops_before_dinarak_when_the_wallet_is_incomplete_or_the_status_is_wrong()
{
var (svc, trips, _, dinarak) = Build();
trips.Trip.StatusCode = "DISCHARGED";
trips.Wallet = ReadyWallet();
trips.Wallet.WalletNumber = "";
await Assert.ThrowsAsync<BusinessException>(() => svc.ExchangeAsync(1, default));
trips.Wallet = ReadyWallet();
trips.Trip.StatusCode = "RESD";
var ex = await Assert.ThrowsAsync<BusinessException>(() => svc.ExchangeAsync(1, default));
Assert.Equal("NO_AUTHORITY", ex.Code);
Assert.Equal(0, dinarak.Transfers);
}
[Fact]
public async Task Receipt_is_for_bank_transfer_trucks_only()
{
var (svc, trips, _, _) = Build();
trips.Trip.StatusCode = "DISCHARGED";
trips.Wallet = ReadyWallet(); // e-wallet: receipt refused
await Assert.ThrowsAsync<BusinessException>(() => svc.ReceiptAsync(1, default));
trips.Wallet = new TripWallet { Id = 6, Epayment = 0 };
await svc.ReceiptAsync(1, default);
Assert.Contains("status:READY_TO_PAY", trips.Calls);
Assert.Contains("amounts:271.975", trips.Calls);
Assert.Equal("RECEIPT", trips.Logs.Single().Method);
}
[Fact]
public async Task Payment_needs_ready_to_pay_and_resets_the_balance()
{
var (svc, trips, _, _) = Build();
trips.Trip.StatusCode = "DISCHARGED";
trips.Wallet = new TripWallet { Id = 6, Epayment = 0 };
await Assert.ThrowsAsync<BusinessException>(() => svc.PaymentAsync(1, default));
trips.Trip.StatusCode = "READY_TO_PAY";
await svc.PaymentAsync(1, default);
Assert.Contains("exchanged::False:6", trips.Calls);
Assert.Contains("reset-balance", trips.Calls);
}
[Fact]
public async Task Cash_payment_sets_the_option_and_orange_does_not_reset_the_balance()
{
var (svc, trips, _, _) = Build();
trips.Trip.StatusCode = "DISCHARGED";
trips.Wallet = ReadyWallet();
await svc.CashPaymentAsync(1, default);
Assert.Contains("exchanged:CACH_PAYMENT:True:5", trips.Calls);
Assert.Contains("reset-balance", trips.Calls);
trips.Calls.Clear();
await svc.OrangePaymentAsync(1, default);
Assert.Contains("exchanged:ORANGE_PAYMENT:True:5", trips.Calls);
Assert.DoesNotContain("reset-balance", trips.Calls);
}
[Fact]
public async Task Activate_wallet_exchange_refuses_when_dinarak_already_has_the_transfer()
{
var (svc, trips, _, _) = Build(new FakeDinarak(new("000", "SUCCESS"), new DinarakTransferStatus(true, "Success", null)));
trips.Trip.StatusCode = "PENDING_EXCHANGE";
trips.Trip.DinarakReferenceId = 352.1m;
var ex = await Assert.ThrowsAsync<BusinessException>(() => svc.ActivateWalletExchangeAsync(1, default));
Assert.Equal("لايمكن تفعيل الصرف, تم الصرف مسبقا", ex.Message);
Assert.DoesNotContain("bump", trips.Calls);
}
[Fact]
public async Task Activate_wallet_exchange_moves_the_reference_when_nothing_was_sent()
{
var (svc, trips, _, _) = Build();
trips.Trip.StatusCode = "PENDING_EXCHANGE";
trips.Trip.DinarakReferenceId = 352.1m;
await svc.ActivateWalletExchangeAsync(1, default);
Assert.Contains("bump", trips.Calls);
Assert.Equal("{\"DINARAK_REFERENCE_ID\":\"352.11\"}", trips.Logs.Single().New);
}
[Fact]
public async Task Activate_wallet_exchange_refuses_when_the_dinarak_state_cannot_be_read()
{
var (svc, trips, _, _) = Build(new FakeDinarak(new("000", "SUCCESS"), new DinarakTransferStatus(false, "ERROR", null)));
trips.Trip.StatusCode = "PENDING_EXCHANGE";
trips.Trip.DinarakReferenceId = 352.1m;
var ex = await Assert.ThrowsAsync<BusinessException>(() => svc.ActivateWalletExchangeAsync(1, default));
Assert.Equal("DINARAK_STATUS_UNKNOWN", ex.Code);
}
[Fact]
public async Task Print_stores_the_voucher_serial_once()
{
var (svc, trips, _, _) = Build();
trips.Trip.StatusCode = "DISCHARGED";
var v = await svc.PrintAsync(1, default);
Assert.Equal("202600096", v.Serial);
Assert.Equal(271.975m, v.Amount);
Assert.Contains("serial:202600096", trips.Calls);
trips.Calls.Clear();
trips.Trip.VoucherSerialNumber = 202200001;
Assert.Equal("202200001", (await svc.PrintAsync(1, default)).Serial);
Assert.DoesNotContain(trips.Calls, c => c.StartsWith("serial"));
}
}