Add debug logging for integration test streams

Author: rjmholt

test/PowerShellEditorServices.Test.E2E/Processes/LoggingStream.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+
+namespace PowerShellEditorServices.Test.E2E
+{
+    internal class LoggingStream : Stream
+    {
+        private static readonly string s_banner = new('=', 20);
+
+        private readonly Stream _underlyingStream;
+
+        public LoggingStream(Stream underlyingStream)
+        {
+            _underlyingStream = underlyingStream;
+        }
+
+        public override bool CanRead => _underlyingStream.CanRead;
+
+        public override bool CanSeek => _underlyingStream.CanSeek;
+
+        public override bool CanWrite => _underlyingStream.CanWrite;
+
+        public override long Length => _underlyingStream.Length;
+
+        public override long Position { get => _underlyingStream.Position; set => _underlyingStream.Position = value; }
+
+        public override void Flush() => _underlyingStream.Flush();
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int actualCount = _underlyingStream.Read(buffer, offset, count);
+            LogData("READ", buffer, offset, actualCount);
+            return actualCount;
+        }
+
+        public override long Seek(long offset, SeekOrigin origin) => _underlyingStream.Seek(offset, origin);
+
+        public override void SetLength(long value) => _underlyingStream.SetLength(value);
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            LogData("WRITE", buffer, offset, count);
+            _underlyingStream.Write(buffer, offset, count);
+        }
+
+        private static void LogData(string header, byte[] buffer, int offset, int count)
+        {
+            Debug.WriteLine($"{header} |{s_banner.Substring(0, Math.Max(s_banner.Length - header.Length - 2, 0))}");
+            string data = Encoding.UTF8.GetString(buffer, offset, count);
+            Debug.WriteLine(data);
+            Debug.WriteLine(s_banner);
+            Debug.WriteLine("\n");
+        }
+    }
+}

test/PowerShellEditorServices.Test.E2E/Processes/ServerProcess.cs

@@ -15,6 +15,11 @@ namespace PowerShellEditorServices.Test.E2E
     public abstract class ServerProcess : IDisposable
     {
         private readonly ISubject<System.Reactive.Unit> _exitedSubject;
+
+        private readonly Lazy<Stream> _inStreamLazy;
+
+        private readonly Lazy<Stream> _outStreamLazy;
+
         /// <summary>
         ///     Create a new <see cref="ServerProcess"/>.
         /// </summary>
@@ -37,6 +42,9 @@ protected ServerProcess(ILoggerFactory loggerFactory)
             ServerExitCompletion.SetResult(null); // Start out as if the server has already exited.
 
             Exited = _exitedSubject = new AsyncSubject<System.Reactive.Unit>();
+
+            _inStreamLazy = new Lazy<Stream>(() => new LoggingStream(GetInputStream()));
+            _outStreamLazy = new Lazy<Stream>(() => new LoggingStream(GetOutputStream()));
         }
 
         /// <summary>
@@ -105,21 +113,25 @@ protected virtual void Dispose(bool disposing)
         /// </summary>
         public Task HasExited => ServerExitCompletion.Task;
 
+        protected abstract Stream GetInputStream();
+
+        protected abstract Stream GetOutputStream();
+
         /// <summary>
         ///     The server's input stream.
         /// </summary>
         /// <remarks>
         ///     The connection will write to the server's input stream, and read from its output stream.
         /// </remarks>
-        public abstract Stream InputStream { get; }
+        public Stream InputStream => _inStreamLazy.Value;
 
         /// <summary>
         ///     The server's output stream.
         /// </summary>
         /// <remarks>
         ///     The connection will read from the server's output stream, and write to its input stream.
         /// </remarks>
-        public abstract Stream OutputStream { get; }
+        public Stream OutputStream => _outStreamLazy.Value;
 
         /// <summary>
         ///     Start or connect to the server.