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(); 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 { { "TRANSACTION_RESULT", outcome }, { "REFERENCE", "existing-ref" } }; var source = new TaskCompletionSource>(); 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>(); 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 { { "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()), TimeSpan.Zero); throw new Exception("expected original start exception"); } catch (InvalidOperationException ex) { Check(ReferenceEquals(ex, startError), "start exception was replaced"); } var fault = new TaskCompletionSource>(); 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(); }); 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(); 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(); }); 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 { { "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() == "CardRequested" && frames[1]["value"].Value() == "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 { { "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()); 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() == 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 { { "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() == "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() == "result") == 1 && frames.Last()["result"]["TRANSACTION_RESULT"].Value() == 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(); 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(); }); 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(); 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(); }); 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(); }); 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 { { "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() == "CardRequested" && frames[1]["value"].Value() == "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 { { "ERRORS", error }, { "REFERENCE", "same-reference" } } : new Dictionary { { "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() == "CardRequested" && frames[1]["value"].Value() == "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>(); 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 { { "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() == "CardRequested" && frames[1]["value"].Value() == "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>(); 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 { { "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() == "status") .Select(f => f["value"].Value()).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() == "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() == "result", "full queue dropped or duplicated final"); Check(frames.Take(128).All(f => f["value"].Value() == "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(); }); 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() == "result") == 1 && frames.Last()["type"].Value() == "result", "concurrent callbacks corrupted terminal framing"); Check(frames.Where(f => f["type"].Value() == "status").All(f => f["source"].Value() == "UPDATE" && f["value"].Value() == "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 { { "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 { { "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() == "CardRequested" && frames[1]["value"].Value() == "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 { { "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() == "CardRequested" && frames.Count(f => f["type"].Value() == "result") == 1 && frames.Last()["type"].Value() == "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 { { "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 { { "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()); Check(!absent.ContainsKey("TRANSACTION_TYPE") && !absent.ContainsKey("TOTAL_AMOUNT"), "allowlist synthesized absent provider fields"); } private static void FinalFieldsExcludeSensitiveParameters() { var fields = TransactionStreamFields.Required(new Dictionary { { "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"); } } }