Files
ChipDNAClientCLI/Tests/StreamingTests.cs
T

679 lines
39 KiB
C#

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;
namespace Creditcall.ChipDna.Client
{
internal static class StreamingTests
{
private static int Main()
{
var tests = new Action[] {
SharedExecutionReturnsAuthoritativeResultOnce,
TimeoutDoesNotCancelCompletion,
StartAndTaskErrorsKeepExceptionBehavior,
SubscriptionIsRemovedOnSuccessAndException,
ActiveStreamAcceptsProgressRegardlessOfReference,
RepeatedReferencesKeepSequentialStreamsFresh,
NativeMiuraSequenceKeepsFinalAuthoritative,
NativeMiuraRecoveryCyclesKeepFinalAuthoritative,
NativeNotificationUsesNotificationKey,
ActiveStreamOwnsRemovalUntilExecutionReturns,
SequentialResultsKeepProgressAndFinancialResults,
SdkErrorResultsDoNotSilenceNextStream,
ExecutionFailuresDoNotSilenceNextStream,
TimeoutDoesNotSilenceNextStream,
QueueCapacityCannotDropFinal,
ConcurrentCallbacksKeepValidLinesAndOneFinal,
DisconnectDoesNotInterruptExecution,
SlowConsumerDoesNotBlockCallbacksOrCompletion,
PreauthFieldsAreOptionalProviderValues,
FinalFieldsExcludeSensitiveParameters
};
int failed = 0;
foreach (var test in tests)
{
try { test(); Console.WriteLine("PASS " + test.Method.Name); }
catch (Exception ex) { failed++; Console.WriteLine("FAIL " + test.Method.Name + ": " + ex); }
}
Console.WriteLine($"{tests.Length - failed}/{tests.Length} tests passed");
return failed == 0 ? 0 : 1;
}
private static void Check(bool condition, string message)
{
if (!condition) throw new Exception(message);
}
private static EventParameters Native(string key, string value, string reference = null)
{
var fields = new Dictionary<string, string>();
if (key != null) fields[key] = value;
if (reference != null) fields["REFERENCE"] = reference;
// SDK event construction is internal; no ClientHelper or terminal is started.
return (EventParameters)Activator.CreateInstance(typeof(EventParameters),
BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { fields }, null);
}
private static void CheckUnsubscribed(TransactionProgressTap tap)
{
var listener = typeof(TransactionProgressTap).GetField("listener", BindingFlags.Instance | BindingFlags.NonPublic);
Check(listener.GetValue(tap) == null, "progress subscription survived execution");
}
private static void SharedExecutionReturnsAuthoritativeResultOnce()
{
foreach (var outcome in new[] { "Approved", "Declined", "Cancelled" })
{
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", outcome }, { "REFERENCE", "existing-ref" } };
var source = new TaskCompletionSource<Dictionary<string, string>>();
int starts = 0;
var result = TransactionExecution.Run(() => { starts++; source.SetResult(expected); },
() => source.Task, TimeSpan.FromSeconds(1));
Check(ReferenceEquals(expected, result) && starts == 1,
"shared execution changed result or start count for " + outcome);
}
}
private static void TimeoutDoesNotCancelCompletion()
{
var source = new TaskCompletionSource<Dictionary<string, string>>();
int starts = 0;
var result = TransactionExecution.Run(() => starts++, () => source.Task, TimeSpan.Zero);
Check(result["TRANSACTION_RESULT"] == "TIMEOUT" &&
result["ERRORS"] == "Transaction timed out waiting for device response", "timeout fields changed");
Check(starts == 1 && !source.Task.IsCompleted, "timeout cancelled or restarted the transaction");
source.SetResult(new Dictionary<string, string> { { "TRANSACTION_RESULT", "Approved" } });
Check(source.Task.Result["TRANSACTION_RESULT"] == "Approved", "late SDK completion was disabled");
}
private static void StartAndTaskErrorsKeepExceptionBehavior()
{
var startError = new InvalidOperationException("start");
try
{
TransactionExecution.Run(() => { throw startError; },
() => Task.FromResult(new Dictionary<string, string>()), TimeSpan.Zero);
throw new Exception("expected original start exception");
}
catch (InvalidOperationException ex) { Check(ReferenceEquals(ex, startError), "start exception was replaced"); }
var fault = new TaskCompletionSource<Dictionary<string, string>>();
fault.SetException(new IOException("SDK fault"));
try
{
TransactionExecution.Run(() => { }, () => fault.Task, TimeSpan.FromSeconds(1));
throw new Exception("expected original Task.Wait AggregateException");
}
catch (AggregateException ex) { Check(ex.InnerException is IOException, "Task.Wait exception behavior changed"); }
}
private static void SubscriptionIsRemovedOnSuccessAndException()
{
var tap = new TransactionProgressTap();
int first = 0, second = 0;
tap.Observe((s,v) => first++, () => {
tap.Report("UPDATE", Native("UPDATE", "CardRequested", "first"));
return new Dictionary<string, string>();
});
CheckUnsubscribed(tap);
tap.Report("UPDATE", Native("UPDATE", "CardRequested", "after-first"));
try
{
tap.Observe((s,v) => second++, () => {
tap.Report("UPDATE", Native("UPDATE", "CardRequested", "second"));
throw new IOException("test");
});
}
catch (IOException) { }
tap.Report("UPDATE", Native("UPDATE", "CardRequested", "second"));
Check(first == 1 && second == 1, $"subscriptions leaked: {first}/{second}");
CheckUnsubscribed(tap);
}
private static void ActiveStreamAcceptsProgressRegardlessOfReference()
{
var tap = new TransactionProgressTap();
var delivered = new List<string>();
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted"));
tap.Observe((source, value) => delivered.Add(value), () => {
foreach (var reference in new[] { null, "", "current", "previous" })
tap.Report("UPDATE", Native("UPDATE", "CardRequested", reference));
return new Dictionary<string, string>();
});
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted"));
Check(delivered.SequenceEqual(Enumerable.Repeat("CardRequested", 4)),
"active progress was reference-filtered or delivered outside Observe");
CheckUnsubscribed(tap);
}
private static void RepeatedReferencesKeepSequentialStreamsFresh()
{
var tap = new TransactionProgressTap();
int starts = 0;
for (int i = 0; i < 100; i++)
using (var output = new MemoryStream())
{
var writer = new TransactionStreamWriter(output);
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", "Approved" }, { "REFERENCE", "same-second-reference" } };
var result = tap.Observe(writer.Progress, () => TransactionExecution.Run(() => {
starts++;
var listener = (Delegate)typeof(TransactionProgressTap).GetField("listener", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tap);
Check(listener.GetInvocationList().Length == 1, "sequential transactions accumulated listeners");
tap.Report("UPDATE", Native("UPDATE", "CardRequested", "same-second-reference"));
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted"));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
writer.Complete(new { type = "result", result });
writer.Deliver();
var frames = Frames(output);
Check(frames.Length == 3 && frames[0]["value"].Value<string>() == "CardRequested" &&
frames[1]["value"].Value<string>() == "PinEntryStarted" && ReferenceEquals(result, expected),
"repeated reference silenced progress, reused a buffer or changed the result at transaction " + i);
CheckUnsubscribed(tap);
tap.Report("UPDATE", Native("UPDATE", "CardRemovalRequested"));
}
Check(starts == 100, "sequential progress changed the transaction dispatch count");
}
private static void NativeMiuraSequenceKeepsFinalAuthoritative()
{
foreach (var outcome in new[] { "Approved", "Declined" })
using (var output = new MemoryStream())
{
var tap = new TransactionProgressTap();
var writer = new TransactionStreamWriter(output);
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", outcome }, { "REFERENCE", "miura-ref" } };
int starts = 0;
var result = tap.Observe(writer.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("CARD_STATUS", Native("NOTIFICATION", "Inserted"));
foreach (var update in new[] { "TransactionStarted", "PinEntryStarted", "OnlineAuthRequested", "OnlineAuthCompleted" })
tap.Report("UPDATE", Native("UPDATE", update));
tap.Report("CARD_STATUS", Native("NOTIFICATION", "Removed"));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
tap.Report("UPDATE", Native("UPDATE", "CardRemovalRequested"));
writer.Complete(new { type = "result", result });
writer.Deliver();
var frames = Frames(output);
var values = frames.Take(frames.Length - 1).Select(f => f["value"].Value<string>());
Check(values.SequenceEqual(new[] { "CardRequested", "CardRequested", "Inserted", "TransactionStarted", "PinEntryStarted", "OnlineAuthRequested", "OnlineAuthCompleted" }),
"SDK 3.17 Miura sequence lost or changed normal reference-less progress");
Check(starts == 1 && ReferenceEquals(result, expected) && frames.Length == 8 &&
frames.Last()["result"]["TRANSACTION_RESULT"].Value<string>() == outcome,
"progress changed start count or authoritative " + outcome + " result");
CheckUnsubscribed(tap);
}
}
private static void NativeMiuraRecoveryCyclesKeepFinalAuthoritative()
{
foreach (var cycles in new[] { 1, 3 })
foreach (var outcome in new[] { "Approved", "Declined" })
using (var output = new MemoryStream())
{
var tap = new TransactionProgressTap();
var writer = new TransactionStreamWriter(output);
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", outcome } };
int starts = 0;
var result = tap.Observe(writer.Progress, () => TransactionExecution.Run(() => {
starts++;
for (int i = 0; i < cycles; i++)
{
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("CARD_STATUS", Native("NOTIFICATION", "Inserted"));
tap.Report("UPDATE", Native("UPDATE", "CardRemovalRequested"));
tap.Report("CARD_STATUS", Native("NOTIFICATION", "Removed"));
}
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("CARD_STATUS", Native("NOTIFICATION", "Inserted"));
foreach (var update in new[] { "TransactionStarted", "PinEntryStarted", "OnlineAuthRequested", "OnlineAuthCompleted" })
tap.Report("UPDATE", Native("UPDATE", update));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
tap.Report("UPDATE", Native("UPDATE", "CardRemovalRequested"));
writer.Complete(new { type = "result", result });
writer.Deliver();
var frames = Frames(output);
var expectedProgress = Enumerable.Range(0, cycles)
.SelectMany(i => new[] { "UPDATE:CardRequested", "CARD_STATUS:Inserted", "UPDATE:CardRemovalRequested" })
.Concat(new[] { "UPDATE:CardRequested", "CARD_STATUS:Inserted", "UPDATE:TransactionStarted",
"UPDATE:PinEntryStarted", "UPDATE:OnlineAuthRequested", "UPDATE:OnlineAuthCompleted" });
Check(frames.Take(frames.Length - 1).All(f => f["type"].Value<string>() == "status") &&
frames.Take(frames.Length - 1).Select(f => f["source"] + ":" + f["value"]).SequenceEqual(expectedProgress),
"Miura recovery prompts were dropped, reordered, deduplicated, or included Removed");
Check(starts == 1 && ReferenceEquals(result, expected) &&
frames.Count(f => f["type"].Value<string>() == "result") == 1 &&
frames.Last()["result"]["TRANSACTION_RESULT"].Value<string>() == outcome,
"recovery progress changed transaction execution or the authoritative final result");
CheckUnsubscribed(tap);
}
}
private static void NativeNotificationUsesNotificationKey()
{
var tap = new TransactionProgressTap();
var delivered = new List<string>();
tap.Observe((source, value) => delivered.Add(source + ":" + value), () => {
tap.Report("CARD_STATUS", Native("CARD_STATUS", "Inserted"));
foreach (var value in new[] { "Inserted", "Tapped", "Swiped" })
tap.Report("CARD_STATUS", Native("NOTIFICATION", value));
tap.Report("CARD_STATUS", Native("NOTIFICATION", "Removed", "native-key"));
tap.Report("CARD_STATUS", Native("NOTIFICATION", "Unknown"));
tap.Report("UPDATE", Native("PAN", "4761730000001133"));
tap.Report("UPDATE", null);
return new Dictionary<string, string>();
});
Check(delivered.SequenceEqual(new[] { "CARD_STATUS:Inserted", "CARD_STATUS:Tapped", "CARD_STATUS:Swiped" }),
"native NOTIFICATION extraction used CARD_STATUS, exposed card data, or changed the wire source");
}
private static void ActiveStreamOwnsRemovalUntilExecutionReturns()
{
var tap = new TransactionProgressTap();
var delivered = new List<string>();
var removals = new[] { "CardRemovalRequested", "CardRemovalEnforced" };
foreach (var removal in removals)
tap.Report("UPDATE", Native("UPDATE", removal));
tap.Observe((source, value) => delivered.Add(source + ":" + value), () => {
tap.Report("UPDATE", Native("UPDATE", "CardRequested", ""));
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted", "previous"));
tap.Report("SIGNATURE", Native(null, null));
tap.Report("PAUSE", Native("PAUSE_STATE", "PostCardDetails"));
foreach (var removal in removals)
foreach (var reference in new[] { null, "", "current", "previous" })
{
tap.Report("UPDATE", Native("UPDATE", removal, reference));
tap.Report("CARD_STATUS", Native("NOTIFICATION", "Removed", reference));
}
return new Dictionary<string, string>();
});
foreach (var removal in removals)
tap.Report("UPDATE", Native("UPDATE", removal));
tap.Observe((source, value) => delivered.Add(source + ":" + value), () => {
// Late display-only updates are accepted by the current stream.
foreach (var removal in removals)
{
tap.Report("UPDATE", Native("UPDATE", removal));
tap.Report("UPDATE", Native("UPDATE", removal, "previous"));
}
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted", "previous"));
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("UPDATE", Native("UPDATE", "Approved"));
return new Dictionary<string, string>();
});
var expected = new[] { "UPDATE:CardRequested", "UPDATE:PinEntryStarted", "SIGNATURE:Requested", "PAUSE:Paused" }
.Concat(removals.SelectMany(value => Enumerable.Repeat("UPDATE:" + value, 4)))
.Concat(removals.SelectMany(value => Enumerable.Repeat("UPDATE:" + value, 2)))
.Concat(new[] { "UPDATE:PinEntryStarted", "UPDATE:CardRequested" });
Check(delivered.SequenceEqual(expected), "active-stream removal prompts were filtered, reordered or delivered after cleanup");
CheckUnsubscribed(tap);
}
private static void SequentialResultsKeepProgressAndFinancialResults()
{
foreach (var outcome in new[] { "Approved", "Declined", "Cancelled" })
{
var tap = new TransactionProgressTap();
int starts = 0;
foreach (var resultCode in new[] { outcome, "Approved" })
using (var output = new MemoryStream())
{
var writer = new TransactionStreamWriter(output);
var expected = new Dictionary<string, string> {
{ "TRANSACTION_RESULT", resultCode }, { "REFERENCE", "unchanged-reference" },
{ "TOTAL_AMOUNT", "3100" }, { "RECEIPT_DATA_CARDHOLDER", "synthetic-receipt" }
};
var result = tap.Observe(writer.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted", "unchanged-reference"));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
writer.Complete(new { type = "result", result });
writer.Deliver();
var frames = Frames(output);
Check(ReferenceEquals(result, expected) && frames.Length == 3 &&
frames[0]["value"].Value<string>() == "CardRequested" &&
frames[1]["value"].Value<string>() == "PinEntryStarted" &&
JToken.DeepEquals(frames[2]["result"], JObject.FromObject(expected)),
"sequential " + outcome + " result lost progress or changed authoritative fields");
CheckUnsubscribed(tap);
}
Check(starts == 2, "sequential " + outcome + " result changed dispatch count");
}
}
private static void SdkErrorResultsDoNotSilenceNextStream()
{
foreach (var error in new[] { "ClientNotConnectedToServer", "AmountTooSmall", "MissingParameter", "NoPinPadsAvailable",
"TransactionInProgress", "ClientNotConnectedToServer,AmountTooSmall", "500005", "Unknown" })
{
var tap = new TransactionProgressTap();
int starts = 0;
foreach (var failed in new[] { true, false })
using (var output = new MemoryStream())
{
var writer = new TransactionStreamWriter(output);
var expected = failed ? new Dictionary<string, string> { { "ERRORS", error }, { "REFERENCE", "same-reference" } }
: new Dictionary<string, string> { { "TRANSACTION_RESULT", "Approved" }, { "REFERENCE", "same-reference" } };
var result = tap.Observe(writer.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted", "same-reference"));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
writer.Complete(new { type = "result", result });
writer.Deliver();
var frames = Frames(output);
Check(ReferenceEquals(result, expected) && frames.Length == 3 &&
frames[0]["value"].Value<string>() == "CardRequested" &&
frames[1]["value"].Value<string>() == "PinEntryStarted" &&
JToken.DeepEquals(frames[2]["result"], JObject.FromObject(expected)),
"SDK error silenced subsequent progress or changed final fields: " + error);
CheckUnsubscribed(tap);
}
Check(starts == 2, "SDK error changed transaction dispatch count: " + error);
}
}
private static void ExecutionFailuresDoNotSilenceNextStream()
{
foreach (var failure in new[] { "start exception", "cancelled completion", "faulted completion" })
using (var firstOutput = new MemoryStream())
using (var nextOutput = new MemoryStream())
{
var tap = new TransactionProgressTap();
var first = new TransactionStreamWriter(firstOutput);
var completion = new TaskCompletionSource<Dictionary<string, string>>();
var startError = new InvalidOperationException("synthetic start failure");
int starts = 0;
bool caught = false;
try
{
tap.Observe(first.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
if (failure == "start exception") throw startError;
Task.Run(() => {
if (failure == "cancelled completion") completion.SetCanceled();
else completion.SetException(new IOException("synthetic SDK fault"));
});
}, () => completion.Task, TimeSpan.FromSeconds(5)));
}
catch (InvalidOperationException ex)
{
caught = failure == "start exception" && ReferenceEquals(ex, startError);
}
catch (AggregateException ex)
{
caught = failure == "cancelled completion" ? ex.InnerException is TaskCanceledException
: failure == "faulted completion" && ex.InnerException is IOException;
}
Check(caught, "execution exception/cancellation behavior changed for " + failure);
CheckUnsubscribed(tap);
first.Complete(new { type = "error", error = "Transaction stream failed" });
first.Deliver();
tap.Report("UPDATE", Native("UPDATE", "CardRemovalRequested"));
var next = new TransactionStreamWriter(nextOutput);
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", "Declined" }, { "REFERENCE", "next" } };
var result = tap.Observe(next.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted", "next"));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
next.Complete(new { type = "result", result });
next.Deliver();
var frames = Frames(nextOutput);
Check(starts == 2 && ReferenceEquals(result, expected) && frames.Length == 3 &&
frames[0]["value"].Value<string>() == "CardRequested" &&
frames[1]["value"].Value<string>() == "PinEntryStarted" &&
JToken.DeepEquals(frames[2]["result"], JObject.FromObject(expected)),
"next transaction lost progress or changed result after " + failure);
CheckUnsubscribed(tap);
}
}
private static void TimeoutDoesNotSilenceNextStream()
{
var tap = new TransactionProgressTap();
var pending = new TaskCompletionSource<Dictionary<string, string>>();
int starts = 0;
using (var firstOutput = new MemoryStream())
using (var nextOutput = new MemoryStream())
{
var first = new TransactionStreamWriter(firstOutput);
var timeout = tap.Observe(first.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
}, () => pending.Task, TimeSpan.Zero));
first.Complete(new { type = "result", result = timeout });
first.Deliver();
CheckUnsubscribed(tap);
var next = new TransactionStreamWriter(nextOutput);
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", "Approved" }, { "REFERENCE", "next" } };
var result = tap.Observe(next.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted", "next"));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
next.Complete(new { type = "result", result });
next.Deliver();
var frames = Frames(nextOutput);
Check(frames.Where(f => f["type"].Value<string>() == "status")
.Select(f => f["value"].Value<string>()).SequenceEqual(new[] { "CardRequested", "PinEntryStarted" }),
"next transaction lost fresh progress after the previous timeout");
Check(starts == 2 && !pending.Task.IsCompleted && ReferenceEquals(result, expected) &&
frames.Last()["result"]["TRANSACTION_RESULT"].Value<string>() == "Approved",
"progress recovery changed dispatch count, pending completion or the next financial result");
CheckUnsubscribed(tap);
}
}
private static JObject[] Frames(MemoryStream stream)
{
var text = Encoding.UTF8.GetString(stream.ToArray());
Check(text.Length == 0 || text[0] != '\uFEFF', "stream contained a BOM");
return text.Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries).Select(JObject.Parse).ToArray();
}
private static void QueueCapacityCannotDropFinal()
{
using (var output = new MemoryStream())
{
var writer = new TransactionStreamWriter(output);
for (int i = 0; i < 1000; i++) writer.Progress("UPDATE", "CardRequested");
writer.Complete(new { type = "result", result = new { TRANSACTION_RESULT = "Approved" } });
writer.Complete(new { type = "error", error = "duplicate" });
writer.Progress("UPDATE", "PinEntryStarted");
writer.Deliver();
writer.Deliver();
var frames = Frames(output);
Check(frames.Length == 129 && frames.Last()["type"].Value<string>() == "result", "full queue dropped or duplicated final");
Check(frames.Take(128).All(f => f["value"].Value<string>() == "CardRequested"), "progress arrived after final");
}
}
private static void ConcurrentCallbacksKeepValidLinesAndOneFinal()
{
using (var output = new MemoryStream())
{
var writer = new TransactionStreamWriter(output);
var delivery = Task.Run(() => writer.Deliver());
var tap = new TransactionProgressTap();
tap.Observe(writer.Progress, () => {
Parallel.For(0, 5000, i => tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted")));
return new Dictionary<string, string>();
});
writer.Complete(new { type = "result", result = new { TRANSACTION_RESULT = "Declined" } });
Check(delivery.Wait(TimeSpan.FromSeconds(5)), "writer did not finish");
var frames = Frames(output);
Check(frames.Count(f => f["type"].Value<string>() == "result") == 1 &&
frames.Last()["type"].Value<string>() == "result", "concurrent callbacks corrupted terminal framing");
Check(frames.Where(f => f["type"].Value<string>() == "status").All(f =>
f["source"].Value<string>() == "UPDATE" && f["value"].Value<string>() == "PinEntryStarted"),
"concurrent callbacks corrupted status fields");
}
}
private sealed class DisconnectedStream : MemoryStream
{
public override void Write(byte[] buffer, int offset, int count) { throw new IOException("disconnected"); }
}
private static void DisconnectDoesNotInterruptExecution()
{
var tap = new TransactionProgressTap();
int starts = 0;
using (var output = new DisconnectedStream())
{
var writer = new TransactionStreamWriter(output);
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", "Approved" } };
var result = tap.Observe(writer.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
writer.Deliver(); // The disconnected consumer cannot abort execution.
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted"));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
writer.Complete(new { type = "result", result });
writer.Progress("UPDATE", "CardRequested");
Check(starts == 1 && ReferenceEquals(result, expected), "disconnect changed final transaction result");
CheckUnsubscribed(tap);
}
using (var output = new MemoryStream())
{
var writer = new TransactionStreamWriter(output);
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", "Declined" } };
var result = tap.Observe(writer.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted"));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1)));
writer.Complete(new { type = "result", result });
writer.Deliver();
var frames = Frames(output);
Check(starts == 2 && ReferenceEquals(result, expected) && frames.Length == 3 &&
frames[0]["value"].Value<string>() == "CardRequested" &&
frames[1]["value"].Value<string>() == "PinEntryStarted" &&
JToken.DeepEquals(frames[2]["result"], JObject.FromObject(expected)),
"disconnected previous stream suppressed progress, reused its buffer or changed the next result");
CheckUnsubscribed(tap);
}
}
private sealed class BlockingStream : MemoryStream
{
internal readonly ManualResetEventSlim WriteEntered = new ManualResetEventSlim();
internal readonly ManualResetEventSlim Release = new ManualResetEventSlim();
public override void Write(byte[] buffer, int offset, int count)
{
WriteEntered.Set();
if (!Release.Wait(TimeSpan.FromSeconds(10))) throw new IOException("test consumer stayed blocked");
base.Write(buffer, offset, count);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
Release.Set();
WriteEntered.Dispose();
Release.Dispose();
}
base.Dispose(disposing);
}
}
private static void SlowConsumerDoesNotBlockCallbacksOrCompletion()
{
using (var output = new BlockingStream())
{
var tap = new TransactionProgressTap();
var writer = new TransactionStreamWriter(output);
var delivery = Task.Run(() => writer.Deliver());
var expected = new Dictionary<string, string> { { "TRANSACTION_RESULT", "Approved" } };
int starts = 0;
var execution = Task.Run(() => tap.Observe(writer.Progress, () => TransactionExecution.Run(() => {
starts++;
tap.Report("UPDATE", Native("UPDATE", "CardRequested"));
Check(output.WriteEntered.Wait(TimeSpan.FromSeconds(5)), "consumer never reached the blocked write");
Parallel.For(0, 5000, i => tap.Report("UPDATE", Native("UPDATE", "PinEntryStarted")));
}, () => Task.FromResult(expected), TimeSpan.FromSeconds(1))));
try
{
Check(execution.Wait(TimeSpan.FromSeconds(5)), "slow consumer blocked SDK callbacks or execution");
Check(starts == 1 && ReferenceEquals(execution.Result, expected), "slow consumer changed financial completion");
CheckUnsubscribed(tap);
writer.Complete(new { type = "result", result = execution.Result });
tap.Report("UPDATE", Native("UPDATE", "CardRemovalRequested"));
}
finally
{
output.Release.Set();
writer.Complete(new { type = "error", error = "test cleanup" });
Check(execution.Wait(TimeSpan.FromSeconds(5)), "execution did not exit after consumer release");
Check(delivery.Wait(TimeSpan.FromSeconds(5)), "delivery did not exit after consumer release");
}
var frames = Frames(output);
Check(frames[0]["value"].Value<string>() == "CardRequested" &&
frames.Count(f => f["type"].Value<string>() == "result") == 1 &&
frames.Last()["type"].Value<string>() == "result" &&
JToken.DeepEquals(frames.Last()["result"], JObject.FromObject(expected)),
"slow consumer reordered progress, lost the final result or delivered progress after final");
}
}
private static void PreauthFieldsAreOptionalProviderValues()
{
var verification = TransactionStreamFields.Required(new Dictionary<string, string> {
{ "TRANSACTION_RESULT", "APPROVED" }, { "TRANSACTION_TYPE", "ACCOUNT VERIFICATION" },
{ "REFERENCE", "verification-ref" }, { "PAN_MASKED", "************1133" }
});
Check(verification["TRANSACTION_TYPE"] == "ACCOUNT VERIFICATION" &&
verification["TRANSACTION_RESULT"] == "APPROVED" && !verification.ContainsKey("TOTAL_AMOUNT"),
"optional verification amount was fabricated or provider type changed");
var monetary = TransactionStreamFields.Required(new Dictionary<string, string> {
{ "TRANSACTION_TYPE", "SALE" }, { "TOTAL_AMOUNT", "3100" }
});
Check(monetary["TRANSACTION_TYPE"] == "SALE" && monetary["TOTAL_AMOUNT"] == "3100",
"provider monetary fields were changed or omitted");
var absent = TransactionStreamFields.Required(new Dictionary<string, string>());
Check(!absent.ContainsKey("TRANSACTION_TYPE") && !absent.ContainsKey("TOTAL_AMOUNT"),
"allowlist synthesized absent provider fields");
}
private static void FinalFieldsExcludeSensitiveParameters()
{
var fields = TransactionStreamFields.Required(new Dictionary<string, string> {
{ "TRANSACTION_RESULT", "Approved" }, { "PAN", "1234567890123456" },
{ "PAN_MASKED", "1234567890123456" }, { "CVV", "123" }, { "PIN", "1234" },
{ "TRACK_DATA", "track-secret" }, { "RAW", "raw-secret" }, { "CARD_HASH", "hash" },
{ "CARD_REFERENCE", "ref" }, { "RECEIPT_DATA_CARDHOLDER", "receipt" }
});
Check(!fields.ContainsKey("PAN") && !fields.ContainsKey("CVV") && !fields.ContainsKey("PIN") &&
!fields.ContainsKey("TRACK_DATA") && !fields.ContainsKey("RAW") && fields["PAN_MASKED"] == "",
"sensitive fields crossed structured boundary");
Check(fields["CARD_HASH"] == "hash" && fields["CARD_REFERENCE"] == "ref" && fields["RECEIPT_DATA_CARDHOLDER"] == "receipt", "required final fields were lost");
Check(TransactionStreamFields.MaskedCardNumber("123456******1234") == "123456******1234" &&
TransactionStreamFields.MaskedCardNumber("476173******1133") == "476173******1133" &&
TransactionStreamFields.MaskedCardNumber("************1133") == "************1133" &&
TransactionStreamFields.MaskedCardNumber("1234567890123456****") == "" &&
TransactionStreamFields.MaskedCardNumber("34373631373330303030303031313333") == "", "valid masking rejected or encoding/full digits treated as masking");
Check(!TransactionStreamFields.IsProgress("PAN", "CardRequested") &&
!TransactionStreamFields.IsProgress("UPDATE", "1234567890123456") &&
!TransactionStreamFields.IsProgress("CARD_STATUS", "Removed"), "unsafe progress permitted");
}
}
}