LiveTestServer basic execution flow, vs-csproj for test project, build fixes (#262)

* LiveTestServer basic execution flow, more vs-csproj, build fixes

Author: brywang-msft

.gitignore

@@ -271,4 +271,5 @@ PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/*.Code.ps1
 
 # LiveTestFramework test results
 PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/Results/
+PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/vs-csproj/Results/
 PSSwagger.LiveTestFramework/test/Pester/PesterResults.xml

PSSwagger.LiveTestFramework/netcoreapp20.proj

@@ -0,0 +1,11 @@
+<Project ToolsVersion="15.0">
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0' ">
+    <PackageReference Include="Microsoft.NETCore.App" Version="2.0.0-preview2-25407-01" />
+    <PackageReference Include="NETStandard.Library" Version="2.0.0-preview2-25401-01" />
+    <PackageReference Include="Microsoft.CSharp" Version="4.4.0-preview2-25405-01" />
+  </ItemGroup>
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0' ">
+    <DefineConstants>$(DefineConstants);CORECLR</DefineConstants>
+    <DebugType>portable</DebugType>
+  </PropertyGroup>
+</Project>

PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Class1.cs

@@ -0,0 +1,53 @@
+namespace PSSwagger.LTF.Lib
+{
+    using Interfaces;
+    using Messages;
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Contains metadata for a generated module being tested.
+    /// </summary>
+    public class GeneratedModule
+    {
+        private IRunspaceManager runspace;
+
+        public string ModulePath { get; set; }
+
+        public IList<GeneratedModule> RequiredModules { get; set; }
+
+        public GeneratedModule(IRunspaceManager runspace)
+        {
+            this.runspace = runspace;
+            this.RequiredModules = new List<GeneratedModule>();
+        }
+
+        public virtual IEnumerable ProcessRequest(LiveTestRequest request)
+        {
+            return null;
+        }
+
+        public virtual void Load(bool force = false)
+        {
+            foreach (GeneratedModule requiredModule in this.RequiredModules)
+            {
+                requiredModule.Load(force: force);
+            }
+
+            ICommandBuilder command = this.runspace.CreateCommand();
+            command.Command = "Import-Module";
+            if (!String.IsNullOrEmpty(ModulePath))
+            {
+                command.AddParameter("Name", this.ModulePath, switchParameter: false);
+            }
+
+            if (force)
+            {
+                command.AddParameter("Force", true, switchParameter: true);
+            }
+
+            command.Invoke();
+        }
+    }
+}

PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/GeneratedModule.cs

@@ -0,0 +1,76 @@
+namespace PSSwagger.LTF.Lib.IO
+{
+    using Interfaces;
+    using System;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// Read valid JSON blocks.
+    /// </summary>
+    public class JsonBlockPipe : IInputPipe
+    {
+        private IInputPipe characterReader;
+        
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="characterReader">InputPipe to use for reading single characters.</param>
+        public JsonBlockPipe(IInputPipe characterReader)
+        {
+            this.characterReader = characterReader;
+        }
+
+        /// <summary>
+        /// Not implemented for JsonBlockPipe.
+        /// </summary>
+        public char ReadChar()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Read a single valid JSON block. Ignores any characters until the first { is read. Ends when the matching } character is read.
+        /// </summary>
+        /// <typeparam name="T">Type of block to read and deserialize.</typeparam>
+        /// <returns>Block of type <typeparamref name="T"/>.</returns>
+        public async Task<T> ReadBlockAsync<T>() where T : class
+        {
+            string jsonString = String.Empty;
+            int openBraces = 0;
+            while (openBraces > 0 || String.IsNullOrEmpty(jsonString))
+            {
+                char c = this.characterReader.ReadChar();
+                switch (c)
+                {
+                    case '{':
+                        openBraces++;
+                        jsonString += c;
+                        break;
+                    case '}':
+                        if (openBraces > 0)
+                        {
+                            openBraces--;
+                            jsonString += c;
+                        }
+                        break;
+                    default:
+                        if (openBraces > 0)
+                        {
+                            jsonString += c;
+                        }
+                        break;
+                }
+            }
+
+            return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(jsonString);
+        }
+
+        /// <summary>
+        /// Not implemented for JsonBlockPipe.
+        /// </summary>
+        public string ReadLine()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/IO/JsonBlockPipe.cs

@@ -0,0 +1,143 @@
+namespace PSSwagger.LTF.Lib.IO
+{
+    using Interfaces;
+    using System;
+    using System.IO;
+    using System.IO.Pipes;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    public delegate void NamedPipeClientDataReceived(string message);
+
+    /// <summary>
+    /// I/O operations for named pipe client.
+    /// </summary>
+    public class NamedPipeClient : IInputPipe, IOutputPipe, IDisposable
+    {
+        private NamedPipeClientStream stream;
+        private StreamReader reader;
+        private StreamWriter writer;
+
+        /// <summary>
+        /// Fired when the client reads a new line of data in its asynchronous processing thread.
+        /// </summary>
+        public event NamedPipeClientDataReceived OnDataReceived;
+
+        /// <summary>
+        /// Gets if the named pipe client is connected.
+        /// </summary>
+        public bool IsConnected
+        {
+            get
+            {
+                return this.stream.IsConnected;
+            }
+        }
+
+        /// <summary>
+        /// Create a named pipe client on the local machine.
+        /// </summary>
+        /// <param name="pipeName">Name of pipe.</param>
+        public NamedPipeClient(string pipeName)
+        {
+            this.stream = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut);
+            this.reader = null;
+            this.writer = null;
+        }
+
+        /// <summary>
+        /// Connect to the named pipe.
+        /// </summary>
+        public void Connect()
+        {
+            this.stream.Connect();
+            this.reader = new StreamReader(this.stream);
+            this.writer = new StreamWriter(this.stream);
+        }
+
+        /// <summary>
+        /// Start the data processing thread.
+        /// </summary>
+        public void BeginProcessing()
+        {
+            new Thread(() =>
+            {
+                while (this.stream.IsConnected)
+                {
+                    string line = this.ReadLine();
+                    OnDataReceived?.Invoke(line);
+                }
+            }){ IsBackground = true }.Start();
+        }
+
+        /// <summary>
+        /// Dispose the StreamReader, StreamWriter, and NamedClientPipeStream.
+        /// </summary>
+        public void Dispose()
+        {
+            this.reader?.Dispose();
+            this.writer?.Dispose();
+            this.stream?.Dispose();
+        }
+
+        /// <summary>
+        /// Flush the NamedClientPipeStream.
+        /// </summary>
+        public void Flush()
+        {
+            this.stream.Flush();
+        }
+
+        /// <summary>
+        /// Read a single character.
+        /// </summary>
+        /// <returns>Character read.</returns>
+        public char ReadChar()
+        {
+            return (char)this.reader.Read();
+        }
+
+        /// <summary>
+        /// Write a single character.
+        /// </summary>
+        /// <param name="b">Character to write.</param>
+        public void Write(char b)
+        {
+            this.writer.Write(b);
+        }
+
+        /// <summary>
+        /// Write the given string then a new line.
+        /// </summary>
+        /// <param name="line">Line to write, not including new line.</param>
+        public void WriteLine(string line)
+        {
+            this.writer.WriteLine(line);
+        }
+
+        /// <summary>
+        /// Read until the next new line character.
+        /// </summary>
+        /// <returns>All text input up to but not including the new line character.</returns>
+        public string ReadLine()
+        {
+            return this.reader.ReadLine();
+        }
+
+        /// <summary>
+        /// NotImplemented
+        /// </summary>
+        public Task<T> ReadBlockAsync<T>() where T : class
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// NotImplemented
+        /// </summary>
+        public Task WriteBlockAsync<T>(T msg) where T : class
+        {
+            throw new NotImplementedException();
+        }
+    }
+}