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; /// The action service against in-memory fakes: card arithmetic, status rules, what is (not) written when Dinarak refuses. 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 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 GetAsync(long id, CancellationToken ct = default) => Task.FromResult(Trip); public Task LockAsync(long id, CancellationToken ct = default) { Calls.Add("lock"); return Task.FromResult(new(Trip.StatusCode, Trip.DieselCharge)); } public Task GetActiveWalletByTruckAsync(string tn, CancellationToken ct = default) => Task.FromResult(Wallet); public Task GetWalletAsync(long walletId, CancellationToken ct = default) => Task.FromResult(Wallet); public Task GetAuditModeAsync(CancellationToken ct = default) => Task.FromResult(false); public Task GetFirstPaymentValueAsync(CancellationToken ct = default) => Task.FromResult(100m); public Task>> GetVariablesAsync(DateTime loadingDate, CancellationToken ct = default) => Task.FromResult>>( [ 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 GetWaterFlagAsync(long id, CancellationToken ct = default) => Task.FromResult(null); public Task CalculateDieselAsync(long id, CancellationToken ct = default) => Task.FromResult(Diesel); public Task CalculateAmountAsync(long id, CancellationToken ct = default) => Task.FromResult(271.975m); public Task HasTransferLogAsync(long id, CancellationToken ct = default) => Task.FromResult(true); public Task> GetTripsOfPeriodAsync(DateTime from, DateTime to, CancellationToken ct = default) => Task.FromResult>([]); public Task GetActiveCardAsync(string tn, CancellationToken ct = default) => Task.FromResult(Card); public Task 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 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> SearchLogAsync(long tripId, PageRequest page, CancellationToken ct = default) => throw new NotSupportedException(); public Task> SearchAsync(TripQuery query, PageRequest page, CancellationToken ct = default) => throw new NotSupportedException(); public Task> ReportAsync(TripQuery query, CancellationToken ct = default) => throw new NotSupportedException(); public Task> DieselReportAsync(DieselReportQuery query, CancellationToken ct = default) => throw new NotSupportedException(); public Task> CardsAsync(string? tn, CancellationToken ct = default) => throw new NotSupportedException(); public Task> BankReportAsync(BankReportQuery query, CancellationToken ct = default) => throw new NotSupportedException(); } private sealed class FakeBalances(List calls) : IRemainingBalanceService { public Task GetAsync(string tn, CancellationToken ct = default) => Task.FromResult(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 RecalculateForPeriodAsync(DateTime startDate, DateTime endDate, long variableGroupId, CancellationToken ct = default) => throw new NotSupportedException(); } private sealed class FakeAmounts : ITripAmountsService { public Task 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 TransferAsync(long tripId, string walletNumber, string nnpn, decimal amount, string receiverName, CancellationToken ct = default) { Transfers++; Last = (walletNumber, amount); return Task.FromResult(result); } public Task GetTransferByMessageIdAsync(long messageId, CancellationToken ct = default) => Task.FromResult(status ?? new(false, "Failed", null)); public Task GetTransferByReferenceAsync(decimal reference, CancellationToken ct = default) => Task.FromResult(status ?? new(false, "Failed", null)); } private sealed class FakeVoucher : IVoucherSerialRepository { public Task 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 ExecuteInTransactionAsync(Func> 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 => "PTADM"; 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(() => 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(() => 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(() => 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(() => 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(() => 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(() => 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(() => svc.ExchangeAsync(1, default)); trips.Wallet = ReadyWallet(); trips.Trip.StatusCode = "RESD"; var ex = await Assert.ThrowsAsync(() => 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(() => 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(() => 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(() => 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(() => 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")); } }