191 lines
8.4 KiB
C#
191 lines
8.4 KiB
C#
using System.Net;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using NTP.Infrastructure.Integrations;
|
|
|
|
namespace NTP.Tests.Refinery;
|
|
|
|
public class DinarakProtocolTests
|
|
{
|
|
[Fact]
|
|
public void Transfer_request_keeps_the_legacy_property_order_and_values()
|
|
{
|
|
var json = DinarakProtocol.BuildTransferRequest("محمد احمد", 271.975m, "26968", 352.1m, "795000000", DinarakProtocol.TransferOperation);
|
|
|
|
Assert.Equal(
|
|
"{\"Name\":\"محمد احمد\",\"Amount\":271.975,\"Description\":\" 26968\",\"MessageId\":\"352.1\",\"Reference\":\"352.1\"," +
|
|
"\"ReceiverID\":\"795000000\",\"OperationName\":\"Transfer\",\"Conditions\":[{\"NationalId\":\"\"}]}", json);
|
|
}
|
|
|
|
[Fact]
|
|
public void Token_request_for_the_log_never_carries_the_password()
|
|
{
|
|
var real = DinarakProtocol.BuildTokenRequest("user", "s3cret");
|
|
var logged = DinarakProtocol.BuildTokenRequestForLog("user");
|
|
|
|
Assert.Equal("{\"username\":\"user\",\"password\":\"s3cret\",\"grant_type\":\"password\"}", real);
|
|
Assert.DoesNotContain("s3cret", logged);
|
|
Assert.Contains("\"username\":\"user\"", logged);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("ZAINJOPX", "Transfer")]
|
|
[InlineData("ORNGJOPX", "Transfer")]
|
|
[InlineData("dnrkjopx", "Transfer")]
|
|
[InlineData("MDFTJOPX", "Transfer")]
|
|
[InlineData("BANKJOPX", "bank salary internal")]
|
|
[InlineData(null, "bank salary internal")]
|
|
public void Wallet_type_decides_the_operation(string? picCode, string expected) =>
|
|
Assert.Equal(expected, DinarakProtocol.OperationFor(picCode));
|
|
|
|
[Fact]
|
|
public void Pic_code_is_read_from_the_alias_answer_and_garbage_gives_null()
|
|
{
|
|
Assert.Equal("ZAINJOPX", DinarakProtocol.ParsePicCode("{\"picCode\":\"ZAINJOPX\",\"name\":\"x\"}"));
|
|
Assert.Null(DinarakProtocol.ParsePicCode("{\"other\":1}"));
|
|
Assert.Null(DinarakProtocol.ParsePicCode("<html>"));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(271.975, 271.975, true)]
|
|
[InlineData(271.975, 271.976, true)]
|
|
[InlineData(271.975, 271.977, false)] // 0.002 > 0.001
|
|
[InlineData(10, 11, false)]
|
|
public void Amount_check_allows_a_thousandth(double calculated, double requested, bool ok) =>
|
|
Assert.Equal(ok, DinarakProtocol.AmountMatches((decimal)calculated, (decimal)requested));
|
|
|
|
[Fact]
|
|
public void Message_ids_are_plain_decimals()
|
|
{
|
|
Assert.Equal("352.1", DinarakProtocol.FormatMessageId(352.1m));
|
|
Assert.Equal("352.11", DinarakProtocol.FormatMessageId(352.11m));
|
|
Assert.Equal("78388", DinarakProtocol.FormatMessageId(78388m));
|
|
}
|
|
|
|
[Fact]
|
|
public void Transfer_answers_map_to_the_legacy_codes()
|
|
{
|
|
Assert.Equal(("000", "SUCCESS"), Pair(DinarakProtocol.MapTransferResponse(200, "{\"status\":{\"name\":\"Success\"}}")));
|
|
Assert.True(DinarakProtocol.MapTransferResponse(200, "{\"status\":{\"name\":\"Success\"}}").Success);
|
|
|
|
var refused = DinarakProtocol.MapTransferResponse(200, "{\"status\":{\"name\":\"Failed\",\"errorMessage\":\"Insufficient funds here\"}}");
|
|
Assert.Equal(("102", "Insufficient_funds_here"), Pair(refused));
|
|
|
|
Assert.Equal(("103", "Bad_gateway"), Pair(DinarakProtocol.MapTransferResponse(502, "Bad gateway")));
|
|
Assert.Equal("104", DinarakProtocol.MapTransferResponse(200, "not json").Code);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("Success", true)]
|
|
[InlineData("Processing", true)]
|
|
[InlineData("New", true)]
|
|
[InlineData("Failed", false)]
|
|
public void Status_lookup_accepts_success_processing_and_new(string name, bool accepted)
|
|
{
|
|
var s = DinarakProtocol.MapStatusResponse(200, "{\"status\":{\"name\":\"" + name + "\"}}");
|
|
Assert.Equal(accepted, s.Accepted);
|
|
Assert.Equal(name, s.StatusName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Status_lookup_with_an_http_error_is_not_accepted()
|
|
{
|
|
var s = DinarakProtocol.MapStatusResponse(404, "nothing");
|
|
Assert.False(s.Accepted);
|
|
Assert.Equal("HTTP_404", s.StatusName);
|
|
Assert.Equal("ERROR", DinarakProtocol.MapStatusResponse(200, "<html>").StatusName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bearer_header_value_is_built_from_the_access_token()
|
|
{
|
|
Assert.Equal("bearer abc", DinarakProtocol.ParseBearer("{\"access_token\":\"abc\",\"expires_in\":1}"));
|
|
Assert.Null(DinarakProtocol.ParseBearer("{\"access_token\":\"\"}"));
|
|
Assert.Null(DinarakProtocol.ParseBearer("nope"));
|
|
}
|
|
|
|
private static (string, string) Pair(NTP.Application.Refinery.Integrations.DinarakTransferResult r) => (r.Code, r.Message);
|
|
}
|
|
|
|
public class DinarakClientTests
|
|
{
|
|
private sealed class Recorder(Func<HttpRequestMessage, HttpResponseMessage> answer) : HttpMessageHandler
|
|
{
|
|
public List<(HttpMethod Method, string Url, string? Body, Dictionary<string, string> Headers)> Calls { get; } = [];
|
|
|
|
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
|
|
{
|
|
var body = request.Content is null ? null : await request.Content.ReadAsStringAsync(cancellationToken);
|
|
var headers = request.Headers.ToDictionary(h => h.Key, h => string.Join(",", h.Value), StringComparer.OrdinalIgnoreCase);
|
|
if (request.Content is not null) headers["Content-Type"] = request.Content.Headers.ContentType!.ToString();
|
|
Calls.Add((request.Method, request.RequestUri!.ToString(), body, headers));
|
|
return answer(request);
|
|
}
|
|
}
|
|
|
|
private static HttpResponseMessage Json(string body, HttpStatusCode code = HttpStatusCode.OK) =>
|
|
new(code) { Content = new StringContent(body, Encoding.UTF8, "application/json") };
|
|
|
|
private static DinarakClient Client(Recorder handler) =>
|
|
new(new HttpClient(handler), new DinarakOptions { BaseUrl = "https://dinarak.invalid/api/", UserName = "u", Password = "p" });
|
|
|
|
[Fact]
|
|
public async Task Token_call_posts_the_login_json_to_token_with_arabic_accept_language()
|
|
{
|
|
var h = new Recorder(_ => Json("{\"access_token\":\"tok\"}"));
|
|
var r = await Client(h).GetTokenAsync();
|
|
|
|
Assert.Equal(200, r.Status);
|
|
var call = Assert.Single(h.Calls);
|
|
Assert.Equal(HttpMethod.Post, call.Method);
|
|
Assert.Equal("https://dinarak.invalid/api/token", call.Url);
|
|
Assert.Equal("{\"username\":\"u\",\"password\":\"p\",\"grant_type\":\"password\"}", call.Body);
|
|
Assert.Equal("ar", call.Headers["Accept-Language"]);
|
|
Assert.StartsWith("application/json", call.Headers["Content-Type"]);
|
|
Assert.False(call.Headers.ContainsKey("Authorization"));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Alias_resolve_and_status_lookup_use_get_with_the_bearer_token()
|
|
{
|
|
var h = new Recorder(_ => Json("{}"));
|
|
var c = Client(h);
|
|
await c.AliasResolveAsync("bearer tok", "795000000");
|
|
await c.GetByMessageIdAsync("bearer tok", "352.1");
|
|
|
|
Assert.Equal("https://dinarak.invalid/api/Transfer/AliasResolve?aliastype=MOBL&value=795000000", h.Calls[0].Url);
|
|
Assert.Equal("https://dinarak.invalid/api/transfer/transferByMessageID?MessageID=352.1", h.Calls[1].Url);
|
|
Assert.All(h.Calls, x =>
|
|
{
|
|
Assert.Equal(HttpMethod.Get, x.Method);
|
|
Assert.Equal("bearer tok", x.Headers["Authorization"]);
|
|
Assert.Equal("en", x.Headers["Accept-Language"]);
|
|
});
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Transfer_posts_the_request_json_and_returns_status_and_body()
|
|
{
|
|
var h = new Recorder(_ => Json("{\"status\":{\"name\":\"Success\"}}"));
|
|
var json = DinarakProtocol.BuildTransferRequest("x", 1.5m, "1", 5m, "795000000", DinarakProtocol.SalaryOperation);
|
|
|
|
var r = await Client(h).TransferAsync("bearer tok", json);
|
|
|
|
Assert.Equal("https://dinarak.invalid/api/transfer/transfer", h.Calls[0].Url);
|
|
Assert.Equal(json, h.Calls[0].Body);
|
|
Assert.Equal("000", DinarakProtocol.MapTransferResponse(r.Status, r.Body).Code);
|
|
using var doc = JsonDocument.Parse(h.Calls[0].Body!);
|
|
Assert.Equal("bank salary internal", doc.RootElement.GetProperty("OperationName").GetString());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Http_errors_are_returned_not_thrown()
|
|
{
|
|
var h = new Recorder(_ => Json("down", HttpStatusCode.BadGateway));
|
|
var r = await Client(h).TransferAsync("bearer tok", "{}");
|
|
|
|
Assert.Equal(502, r.Status);
|
|
Assert.Equal("103", DinarakProtocol.MapTransferResponse(r.Status, r.Body).Code);
|
|
}
|
|
}
|