From bca29f86334e52b67b0fb1ebb233f6d839b21e1b Mon Sep 17 00:00:00 2001
From: "Bryan Wang (PSHCT)" <brywang@microsoft.com>
Date: Tue, 29 Aug 2017 16:41:06 -0700
Subject: [PATCH 1/7] Parameterless execution of
 PSSwagger.LTF.ConsoleServer.exe + test module fixes

---
 .../PSSwagger.LTF.ConsoleServer.csproj        |  4 ++
 .../PSSwagger.LTF.ConsoleServer/Program.cs    | 61 ++++++++++++++++---
 .../PSSwagger.LTF.ConsoleServer/config.json   |  2 +
 .../PSSwagger.LTF.ConsoleServer.csproj        | 10 +++
 .../vs-csproj/packages.config                 |  4 ++
 .../PSSwagger.LiveTestFramework.Tests.psm1    |  4 +-
 6 files changed, 74 insertions(+), 11 deletions(-)
 create mode 100644 PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/config.json
 create mode 100644 PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/vs-csproj/packages.config

diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/PSSwagger.LTF.ConsoleServer.csproj b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/PSSwagger.LTF.ConsoleServer.csproj
index de5da85..64e6192 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/PSSwagger.LTF.ConsoleServer.csproj
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/PSSwagger.LTF.ConsoleServer.csproj
@@ -10,5 +10,9 @@
   <ItemGroup Condition=" '$(TargetFramework)' == 'net452' ">
     <PackageReference Include="System.Management.Automation" Version="6.0.0-alpha17" />
     <PackageReference Include="Microsoft.CSharp" Version="4.4.0-preview2-25405-01" />
+    <PackageReference Include="Newtonsoft.JSON" Version="10.0.1" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Update="config.json" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
index 68fa4ee..5eb94eb 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
@@ -10,6 +10,7 @@ namespace PSSwagger.LTF.ConsoleServer
     using Lib.Models;
     using Lib.PowerShell;
     using Lib.ServiceTracing;
+    using Newtonsoft.Json;
     using System;
     using System.Collections.Generic;
     using System.Globalization;
@@ -20,7 +21,7 @@ class Program
     {
         static void Main(string[] args)
         {
-            ServerArgs serverArgs = new ServerArgs(args);
+            ServerArgs serverArgs = new ServerArgs().Parse("config.json").Parse(args).Validate();
             NamedPipeServer namedPipe = new NamedPipeServer(serverArgs.LogPipeName);
             Logger logger = new Logger(namedPipe, namedPipe);
             if (serverArgs.Errors.Count > 0)
@@ -77,7 +78,7 @@ static void Main(string[] args)
             }
         }
     }
-
+    
     class ServerArgs
     {
         public List<string> SpecificationPaths { get; set; }
@@ -86,13 +87,19 @@ class ServerArgs
         public string LogPipeName { get; set; }
         public List<string> Errors { get; set; }
 
-        public ServerArgs(string[] args)
+        public ServerArgs()
         {
-            this.LogPipeName = "psswagger-ltf-consoleserver";
-            string lastArg = String.Empty;
+            this.Errors = new List<string>();
             this.SpecificationPaths = new List<string>();
             this.ExternalModules = new List<string>();
-            this.Errors = new List<string>();
+            this.LogPipeName = "psswagger-ltf-consoleserver";
+        }
+
+        public ServerArgs Parse(string[] args)
+        {
+            string lastArg = String.Empty;
+            bool resetSpecificationPaths = false;
+            bool resetExternalModules = false;
             foreach (string arg in args)
             {
                 if (!arg.StartsWith("/"))
@@ -103,15 +110,29 @@ public ServerArgs(string[] args)
                             if (!arg.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
                             {
                                 this.Errors.Add("Specification file is not a .json file.");
-                            } else if (!File.Exists(arg))
+                            }
+                            else if (!File.Exists(arg))
                             {
                                 this.Errors.Add(String.Format(CultureInfo.CurrentCulture, "Specification file does not exist: {0}", arg));
-                            } else
+                            }
+                            else
                             {
+                                if (!resetSpecificationPaths)
+                                {
+                                    resetSpecificationPaths = true;
+                                    this.SpecificationPaths.Clear();
+                                }
+
                                 this.SpecificationPaths.Add(arg);
                             }
                             break;
                         case "extmodule":
+                            if (!resetExternalModules)
+                            {
+                                resetExternalModules = true;
+                                this.ExternalModules.Clear();
+                            }
+
                             this.ExternalModules.Add(arg);
                             break;
                         case "testmodule":
@@ -125,16 +146,38 @@ public ServerArgs(string[] args)
                             break;
                     }
                     lastArg = String.Empty;
-                } else
+                }
+                else
                 {
                     lastArg = arg.Substring(1);
                 }
             }
 
+            return this;
+        }
+
+        public ServerArgs Parse(string jsonFilePath)
+        {
+            ServerArgs ret;
+            if (File.Exists(jsonFilePath))
+            {
+                ret = JsonConvert.DeserializeObject<ServerArgs>(File.ReadAllText(jsonFilePath));
+            } else
+            {
+                ret = new ServerArgs();
+            }
+
+            return ret;
+        }
+
+        public ServerArgs Validate()
+        {
             if (String.IsNullOrEmpty(this.ModulePath))
             {
                 this.Errors.Add("No test module path specified.");
             }
+
+            return this;
         }
     }
 }
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/config.json b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/config.json
new file mode 100644
index 0000000..7a73a41
--- /dev/null
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/config.json
@@ -0,0 +1,2 @@
+{
+}
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/vs-csproj/PSSwagger.LTF.ConsoleServer.csproj b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/vs-csproj/PSSwagger.LTF.ConsoleServer.csproj
index e07b498..627a09f 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/vs-csproj/PSSwagger.LTF.ConsoleServer.csproj
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/vs-csproj/PSSwagger.LTF.ConsoleServer.csproj
@@ -32,6 +32,10 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>packages\Newtonsoft.Json.10.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -43,6 +47,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\Program.cs" />
+    <Content Include="..\config.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\PSSwagger.LTF.IO.Lib\vs-csproj\PSSwagger.LTF.IO.Lib.csproj">
@@ -54,6 +61,9 @@
       <Name>PSSwagger.LTF.Lib</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/vs-csproj/packages.config b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/vs-csproj/packages.config
new file mode 100644
index 0000000..f54866f
--- /dev/null
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/vs-csproj/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Newtonsoft.Json" version="10.0.1" targetFramework="net452" />
+</packages>
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/test/PSSwagger.LiveTestFramework.Tests.psm1 b/PSSwagger.LiveTestFramework/test/PSSwagger.LiveTestFramework.Tests.psm1
index 5835cae..e6b194c 100644
--- a/PSSwagger.LiveTestFramework/test/PSSwagger.LiveTestFramework.Tests.psm1
+++ b/PSSwagger.LiveTestFramework/test/PSSwagger.LiveTestFramework.Tests.psm1
@@ -42,7 +42,7 @@ function Initialize-TestDependency {
     }
 
     Import-Module -Name (Split-Path -Path $PSScriptRoot -Parent | Join-Path -ChildPath "build" | Join-Path -ChildPath "PSSwagger.LiveTestFramework.Build.psd1") -Force
-    $failed = $failed -or PSSwagger.LiveTestFramework.Build\Initialize-LTFBuildDependency
+    $failed = $failed -or (PSSwagger.LiveTestFramework.Build\Initialize-LTFBuildDependency)
     if ($failed) {
         Write-Error -Message 'One or more dependencies failed to intialize.'
     } else {
@@ -83,7 +83,7 @@ function Start-TestRun {
             }
 
             $trxLogs += $trxLogFile
-            PSSwagger.LiveTestFramework.Build\Build-LTFBuildDotNetProject -Project $_ -Framework $Framework `
+            PSSwagger.LiveTestFramework.Build\Start-LTFBuildDotNetProject -Project $_ -Framework $Framework `
                                                                           -Publish -Test -TestLogger "trx;LogFileName=$trxLogFile"
         }
     }

From c11ba0cf88727aa50e31f8a3004cf94081163522 Mon Sep 17 00:00:00 2001
From: "Bryan Wang (PSHCT)" <brywang@microsoft.com>
Date: Tue, 29 Aug 2017 17:20:41 -0700
Subject: [PATCH 2/7] Fix parse of config.json

---
 .../PSSwagger.LTF.ConsoleServer/Program.cs    | 27 ++++++++++++++-----
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
index 5eb94eb..1c02222 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
@@ -158,16 +158,31 @@ public ServerArgs Parse(string[] args)
 
         public ServerArgs Parse(string jsonFilePath)
         {
-            ServerArgs ret;
             if (File.Exists(jsonFilePath))
             {
-                ret = JsonConvert.DeserializeObject<ServerArgs>(File.ReadAllText(jsonFilePath));
-            } else
-            {
-                ret = new ServerArgs();
+                ServerArgs fromFile = JsonConvert.DeserializeObject<ServerArgs>(File.ReadAllText(jsonFilePath));
+                if (!String.IsNullOrWhiteSpace(fromFile.ModulePath))
+                {
+                    this.ModulePath = fromFile.ModulePath;
+                }
+
+                if (!String.IsNullOrWhiteSpace(fromFile.LogPipeName))
+                {
+                    this.LogPipeName = fromFile.LogPipeName;
+                }
+
+                if (fromFile.ExternalModules != null && fromFile.ExternalModules.Count > 0)
+                {
+                    this.ExternalModules = fromFile.ExternalModules;
+                }
+
+                if (fromFile.SpecificationPaths != null && fromFile.SpecificationPaths.Count > 0)
+                {
+                    this.SpecificationPaths = fromFile.SpecificationPaths;
+                }
             }
 
-            return ret;
+            return this;
         }
 
         public ServerArgs Validate()

From e2526fef6debe136b92b6af7645a1f41b3f19fe3 Mon Sep 17 00:00:00 2001
From: "Bryan Wang (PSHCT)" <brywang@microsoft.com>
Date: Wed, 30 Aug 2017 08:34:24 -0700
Subject: [PATCH 3/7] Load config.json from .exe directory + composite logger +
 event log logger

---
 .../PSSwagger.LTF.ConsoleServer/Program.cs    | 42 ++++++++++-
 .../EventLogOutputPipe.cs                     | 40 +++++++++++
 .../Logging/CompositeLogger.cs                | 70 +++++++++++++++++++
 .../src/PSSwagger.LTF.Lib/Logging/Logger.cs   |  6 +-
 4 files changed, 152 insertions(+), 6 deletions(-)
 create mode 100644 PSSwagger.LiveTestFramework/src/PSSwagger.LTF.IO.Lib/EventLogOutputPipe.cs
 create mode 100644 PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs

diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
index 1c02222..aa1bb92 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
@@ -15,15 +15,36 @@ namespace PSSwagger.LTF.ConsoleServer
     using System.Collections.Generic;
     using System.Globalization;
     using System.IO;
+    using System.Reflection;
     using System.Threading;
 
     class Program
     {
         static void Main(string[] args)
         {
-            ServerArgs serverArgs = new ServerArgs().Parse("config.json").Parse(args).Validate();
-            NamedPipeServer namedPipe = new NamedPipeServer(serverArgs.LogPipeName);
-            Logger logger = new Logger(namedPipe, namedPipe);
+            ServerArgs serverArgs = new ServerArgs().Parse(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "config.json")).Parse(args).Validate();
+            
+            EventLogOutputPipe eventLogOutputPipe = new EventLogOutputPipe();
+            CompositeLogger logger = new CompositeLogger();
+            if (serverArgs.EnableEventLog)
+            {
+                logger.AddLogger(new Logger(eventLogOutputPipe, eventLogOutputPipe));
+            }
+
+            if (serverArgs.EnablePipeLog)
+            {
+                try
+                {
+                    NamedPipeServer namedPipe = new NamedPipeServer(serverArgs.LogPipeName);
+                    Logger namedPipeLogger = new Logger(namedPipe, namedPipe);
+                    logger.AddLogger(namedPipeLogger);
+                }
+                catch (Exception e)
+                {
+                    logger.LogError("Failed to initialize named pipe logger: " + e.Message);
+                }
+            }
+            
             if (serverArgs.Errors.Count > 0)
             {
                 logger.LogError("Server arguments had errors.");
@@ -86,6 +107,8 @@ class ServerArgs
         public string ModulePath { get; set; }
         public string LogPipeName { get; set; }
         public List<string> Errors { get; set; }
+        public bool EnablePipeLog { get; set; }
+        public bool EnableEventLog { get; set; }
 
         public ServerArgs()
         {
@@ -93,6 +116,8 @@ public ServerArgs()
             this.SpecificationPaths = new List<string>();
             this.ExternalModules = new List<string>();
             this.LogPipeName = "psswagger-ltf-consoleserver";
+            this.EnablePipeLog = true;
+            this.EnableEventLog = false;
         }
 
         public ServerArgs Parse(string[] args)
@@ -150,6 +175,17 @@ public ServerArgs Parse(string[] args)
                 else
                 {
                     lastArg = arg.Substring(1);
+                    switch (lastArg.ToLowerInvariant())
+                    {
+                        case "enablepipelog":
+                            lastArg = String.Empty;
+                            this.EnablePipeLog = true;
+                            break;
+                        case "enableeventlog":
+                            lastArg = String.Empty;
+                            this.EnableEventLog = true;
+                            break;
+                    }
                 }
             }
 
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.IO.Lib/EventLogOutputPipe.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.IO.Lib/EventLogOutputPipe.cs
new file mode 100644
index 0000000..a1b853d
--- /dev/null
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.IO.Lib/EventLogOutputPipe.cs
@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Licensed under the MIT license.
+namespace PSSwagger.LTF.Lib.IO
+{
+    using Interfaces;
+    using System;
+    using System.Diagnostics;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// Read from STDOUT.
+    /// </summary>
+    public class EventLogOutputPipe : IOutputPipe
+    {
+        public Task Write(char b)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task WriteBlock<T>(T msg) where T : class
+        {
+            throw new NotImplementedException();
+        }
+        
+        public Task WriteBlockAsync<T>(T msg) where T : class
+        {
+            throw new NotImplementedException();
+        }
+
+        public async Task WriteLine(string line)
+        {
+            using (EventLog eventLog = new EventLog("Application"))
+            {
+                eventLog.Source = "Application";
+                eventLog.WriteEntry(line);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs
new file mode 100644
index 0000000..f801b03
--- /dev/null
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs
@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Licensed under the MIT license.
+namespace PSSwagger.LTF.Lib.Logging
+{
+    using Interfaces;
+    using Newtonsoft.Json;
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Text;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// Logging interface.
+    /// </summary>
+    public class CompositeLogger : Logger
+    {
+        private IList<Logger> InternalLoggers { get; set; }
+
+        public CompositeLogger() : base(null, null)
+        {
+            this.InternalLoggers = new List<Logger>();
+        }
+
+        public CompositeLogger AddLogger(Logger logger)
+        {
+            this.InternalLoggers.Add(logger);
+            return this;
+        }
+
+        /// <summary>
+        /// Log a single message to output pipe.
+        /// </summary>
+        /// <param name="message">Message to log.</param>
+        public override void Log(string message)
+        {
+            foreach (Logger logger in this.InternalLoggers)
+            {
+                logger.Log(message);
+            }
+        }
+
+        /// <summary>
+        /// Serialize objects into JSON then asynchronously log the final formatted message. Recommended to run this log in a Task.Run context so the object serialization is also async.
+        /// </summary>
+        /// <param name="message">Message with format parameters.</param>
+        /// <param name="objs">Objects to serialize.</param>
+        public override async Task LogAsync(string message, params object[] objs)
+        {
+            foreach (Logger logger in this.InternalLoggers)
+            {
+                logger.LogAsync(message);
+            }
+        }
+
+        /// <summary>
+        /// Log a single message to error pipe.
+        /// </summary>
+        /// <param name="message"></param>
+        public void LogError(string message)
+        {
+            foreach (Logger logger in this.InternalLoggers)
+            {
+                logger.LogError(message);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/Logger.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/Logger.cs
index c26de05..894f84f 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/Logger.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/Logger.cs
@@ -35,7 +35,7 @@ public Logger(IOutputPipe stdout, IOutputPipe stderr, bool timestamp = true, boo
         /// Log a single message to output pipe.
         /// </summary>
         /// <param name="message">Message to log.</param>
-        public void Log(string message)
+        public virtual void Log(string message)
         {
             if (this.stdout != null)
             {
@@ -48,7 +48,7 @@ public void Log(string message)
         /// </summary>
         /// <param name="message">Message with format parameters.</param>
         /// <param name="objs">Objects to serialize.</param>
-        public async Task LogAsync(string message, params object[] objs)
+        public virtual async Task LogAsync(string message, params object[] objs)
         {
             string[] objSerialized = new string[objs.Length];
             for (int i = 0; i < objs.Length; i++)
@@ -74,7 +74,7 @@ public async Task LogAsync(string message, params object[] objs)
         /// Log a single message to error pipe.
         /// </summary>
         /// <param name="message"></param>
-        public void LogError(string message)
+        public virtual void LogError(string message)
         {
             if (this.stderr != null)
             {

From 09a957ba839f76ec7e426e74943d93cfaddf8de4 Mon Sep 17 00:00:00 2001
From: "Bryan Wang (PSHCT)" <brywang@microsoft.com>
Date: Wed, 30 Aug 2017 08:35:29 -0700
Subject: [PATCH 4/7] ASCII -> UTF8

---
 .../src/PSSwagger.LTF.IO.Lib/JsonRpcPipe.cs                     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.IO.Lib/JsonRpcPipe.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.IO.Lib/JsonRpcPipe.cs
index 33e43fa..6b6b3f0 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.IO.Lib/JsonRpcPipe.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.IO.Lib/JsonRpcPipe.cs
@@ -76,7 +76,7 @@ public async Task<T> ReadBlock<T>() where T : class
                     bytes[i] = await this.characterReader.ReadByte();
                 }
 
-                string jsonString = Encoding.ASCII.GetString(bytes);
+                string jsonString = Encoding.UTF8.GetString(bytes);
 
                 if (jsonString.StartsWith("["))
                 {

From 9ca9b7b333c956f07b692096d55c57f58802d6b2 Mon Sep 17 00:00:00 2001
From: "Bryan Wang (PSHCT)" <brywang@microsoft.com>
Date: Wed, 30 Aug 2017 08:56:58 -0700
Subject: [PATCH 5/7] Headers should always be passed as arrays

---
 .../src/PSSwagger.LTF.Lib/Messages/LiveTestRequest.cs  | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Messages/LiveTestRequest.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Messages/LiveTestRequest.cs
index b0fcaa7..950bb2a 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Messages/LiveTestRequest.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Messages/LiveTestRequest.cs
@@ -92,14 +92,8 @@ private LiveTestResult GetLiveTestResult(IEnumerable<object> resultsEnumerable,
                     foreach (KeyValuePair<string, IEnumerable<string>> header in responseMessage.Headers)
                     {
                         string[] headerValues = header.Value.ToArray();
-                        if (headerValues.Length == 1)
-                        {
-                            headersDictionary[header.Key] = headerValues[0];
-                        }
-                        else if (headerValues.Length > 1)
-                        {
-                            headersDictionary[header.Key] = headerValues;
-                        }
+                        // Microsoft.Rest.ClientRuntime.Test expects all headers as arrays
+                        headersDictionary[header.Key] = headerValues;
                     }
 
                     result.Headers = headersDictionary;

From 5d58e41ec7d979f5da0967ef99bb18eb1c3f9130 Mon Sep 17 00:00:00 2001
From: "Bryan Wang (PSHCT)" <brywang@microsoft.com>
Date: Tue, 5 Sep 2017 14:07:06 -0700
Subject: [PATCH 6/7] Bunch of fixes to get happy path working in Azure tests

---
 .../PSSwagger.LTF.ConsoleServer/Program.cs    |   2 +-
 .../Converters/DynamicTypedObjectConverter.cs |  19 +-
 .../Converters/LiveTestRequestConverter.cs    |  17 +-
 .../Interfaces/ICommandPostProcessor.cs       |  15 +
 .../PSSwagger.LTF.Lib/Json/JsonPathFinder.cs  |  32 +-
 .../src/PSSwagger.LTF.Lib/LiveTestServer.cs   |  49 +-
 .../Logging/CompositeLogger.cs                |   4 +-
 .../src/PSSwagger.LTF.Lib/Logging/Logger.cs   |  10 +-
 .../PSSwagger.LTF.Lib/Models/AzurePageType.cs |  62 ++
 .../Models/GeneratedModule.cs                 | 632 +++++++++++++-----
 .../PSSwagger.LTF.Lib/Models/OperationData.cs |  13 +
 .../PSSwagger.LTF.Lib/Models/ParameterData.cs |  45 ++
 .../Models/ResponseTypeData.cs                |  86 +++
 .../Models/RuntimeTypeData.cs                 |  43 +-
 .../PostProcessors/AzurePagePostProcessor.cs  |  40 ++
 .../PowerShell/PowerShellRunspace.cs          |  25 +-
 .../ClientRuntimeServiceTracer.cs             |   8 +-
 .../vs-csproj/PSSwagger.LTF.Lib.csproj        |   3 +
 .../GeneratedModuleTests.cs                   | 540 +++++++++++----
 .../JsonPathFinderTests.cs                    |   6 +-
 .../LiveTestRequestTests.cs                   |   4 +-
 .../Mocks/MockJsonPathFinder.cs               |  45 +-
 .../PowerShellRunspaceTests.cs                |  32 +-
 .../BasicHappyPath/BasicHappyPath.psm1        |   1 +
 .../test/project-xunittest.proj               |   4 +-
 25 files changed, 1401 insertions(+), 336 deletions(-)
 create mode 100644 PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Interfaces/ICommandPostProcessor.cs
 create mode 100644 PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/AzurePageType.cs
 create mode 100644 PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/ResponseTypeData.cs
 create mode 100644 PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/PostProcessors/AzurePagePostProcessor.cs

diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
index aa1bb92..31a21d2 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.ConsoleServer/Program.cs
@@ -95,7 +95,7 @@ static void Main(string[] args)
             // Wait until server exits (usually means the server ran into an internal error)
             while (server.IsRunning)
             {
-                Thread.Sleep(1);
+                Thread.Sleep(2);
             }
         }
     }
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/DynamicTypedObjectConverter.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/DynamicTypedObjectConverter.cs
index 01b4ac0..427d9cb 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/DynamicTypedObjectConverter.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/DynamicTypedObjectConverter.cs
@@ -89,7 +89,24 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
                     if ((val != null) || serializer.NullValueHandling == NullValueHandling.Include)
                     {
                         string propertyName = pi.Name.ToLowerInvariant();
-                        if (this.typeData.Properties.ContainsKey(propertyName) && !String.IsNullOrEmpty(this.typeData.Properties[propertyName].JsonName))
+                        if (this.typeData.Properties.ContainsKey(propertyName) && !String.IsNullOrEmpty(this.typeData.Properties[propertyName].SubNodeName))
+                        {
+                            // AutoRest's TransformationJsonConverter expects these properties to be inside a "properties" object
+                            ParameterData subObjectPropertyInfo = this.typeData.Properties[propertyName];
+                            propertyName = this.typeData.Properties[propertyName].SubNodeName; // This is "properties"
+                            Dictionary<string, object> subObjectNode;
+                            if (dict.ContainsKey(propertyName))
+                            {
+                                subObjectNode = (Dictionary<string, object>)dict[propertyName];
+                            } else
+                            {
+                                subObjectNode = new Dictionary<string, object>();
+                            }
+
+                            subObjectNode[subObjectPropertyInfo.RawJsonName] = val;
+                            val = subObjectNode;
+                        }
+                        else if (this.typeData.Properties.ContainsKey(propertyName) && !String.IsNullOrEmpty(this.typeData.Properties[propertyName].JsonName))
                         {
                             propertyName = this.typeData.Properties[propertyName].JsonName;
                         }
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/LiveTestRequestConverter.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/LiveTestRequestConverter.cs
index 222f997..6c87574 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/LiveTestRequestConverter.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/LiveTestRequestConverter.cs
@@ -41,13 +41,20 @@ public void RegisterSelf(JsonSerializerSettings settings)
                 {
                     RegisterTypeConverter(parameter.Type, settings);
                 }
+                
+                // Don't bother registering the ResponseType for a page response
+                if (operation.ResponseType != null)
+                {
+                    RegisterTypeConverter(operation.ResponseType.TypeData, settings);
+                }
             }
         }
 
         private void RegisterTypeConverter(RuntimeTypeData typeData, JsonSerializerSettings settings)
         {
-            if (typeData != null && typeData.Type != null && typeData.Type.GetConstructor(new Type[] { }) != null)
+            if (typeData != null && typeData.Type != null && typeData.Type.GetConstructor(new Type[] { }) != null && typeData.Properties.Count > 0)
             {
+                Log("Registering JSON converter for type: {0}", typeData.Type.FullName);
                 settings.Converters.Add(new DynamicTypedObjectConverter(typeData));
                 foreach (ParameterData property in typeData.Properties.Values)
                 {
@@ -181,5 +188,13 @@ private bool ConvertObject(object val, Type expectedType, JsonSerializer seriali
 
             return success;
         }
+
+        private void Log(string msg, params object[] args)
+        {
+            if (this.module.Logger != null)
+            {
+                this.module.Logger.Log(msg, args);
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Interfaces/ICommandPostProcessor.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Interfaces/ICommandPostProcessor.cs
new file mode 100644
index 0000000..8d5b23f
--- /dev/null
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Interfaces/ICommandPostProcessor.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Licensed under the MIT license.
+namespace PSSwagger.LTF.Lib.Interfaces
+{
+    using Models;
+
+    /// <summary>
+    /// Process command results before returning to client.
+    /// </summary>
+    public interface ICommandPostProcessor
+    {
+        CommandExecutionResult Process(CommandExecutionResult result);
+    }
+}
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Json/JsonPathFinder.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Json/JsonPathFinder.cs
index 3adb8d8..d55bdc2 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Json/JsonPathFinder.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Json/JsonPathFinder.cs
@@ -7,6 +7,7 @@ namespace PSSwagger.LTF.Lib.Json
     using Newtonsoft.Json.Linq;
     using System;
     using System.Collections.Generic;
+    using System.Linq;
 
     /// <summary>
     /// Provides parsing for a JSON file.
@@ -14,7 +15,23 @@ namespace PSSwagger.LTF.Lib.Json
     public class JsonPathFinder
     {
         private JToken root;
+        private string rootPath = null;
 
+        public virtual string Path
+        {
+            get
+            {
+                if (String.IsNullOrEmpty(this.rootPath))
+                {
+                    System.Text.StringBuilder sb = new System.Text.StringBuilder();
+                    sb.Append("#/");
+                    sb.Append(this.root.Path.Replace(".", "/").ToLowerInvariant());
+                    this.rootPath = sb.ToString();
+                }
+
+                return this.rootPath;
+            }
+        }
         public virtual JsonPathFinder Parent
         {
             get
@@ -35,7 +52,7 @@ public virtual string Key
                 string[] dotSplit = this.root.Path.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
                 if (dotSplit.Length > 1)
                 {
-                    return dotSplit[dotSplit.Length - 2];
+                    return dotSplit[dotSplit.Length - 1];
                 }
 
                 return null;
@@ -72,6 +89,11 @@ public JsonPathFinder(JToken jToken)
             this.root = jToken;
         }
 
+        public virtual JsonPathFinder OpenContainer()
+        {
+            return this.Children().Single();
+        }
+
         public virtual IEnumerable<JsonPathFinder> Find(JsonQueryBuilder queryBuilder)
         {
             return Find(queryBuilder.ToQuery());
@@ -85,6 +107,14 @@ public virtual IEnumerable<JsonPathFinder> Find(string jsonQuery)
             }
         }
 
+        public virtual IEnumerable<JsonPathFinder> Children()
+        {
+            foreach (JToken token in this.root.Children())
+            {
+                yield return new JsonPathFinder(token);
+            }
+        }
+
         public override string ToString()
         {
             return this.root == null ? null : this.root.ToString();
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/LiveTestServer.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/LiveTestServer.cs
index 0c3a189..d80b65c 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/LiveTestServer.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/LiveTestServer.cs
@@ -99,21 +99,33 @@ public async Task RunAsync()
             // Retrieve all module information using the current runspace manager
             this.currentModule = this.parameters.RunspaceManager.GetModuleInfo(this.parameters.ModulePath);
             this.currentModule.Logger = this.parameters.Logger;
-            
-            // For JSON-RPC pipe input/output, add Newtonsoft.Json converters
-            if (this.Input is JsonRpcPipe)
+
+            // Parse specifications/metadata files for extra information, e.g. parameter renaming
+            if (this.parameters.SpecificationPaths != null)
             {
-                JsonRpcPipe jsonRpcPipe = (JsonRpcPipe)this.Input;
-                new LiveTestRequestConverter(this.currentModule).RegisterSelf(jsonRpcPipe.JsonSerializerSettings);
-                if (this.parameters.Logger != null)
+                foreach (string specificationPath in this.parameters.SpecificationPaths)
                 {
-                    this.parameters.Logger.JsonSerializerSettings = jsonRpcPipe.JsonSerializerSettings;
+                    if (this.parameters.Logger != null)
+                    {
+                        this.parameters.Logger.LogAsync("Loading specification file: " + specificationPath);
+                    }
+                    Json.JsonPathFinder jsonFinder = new Json.JsonPathFinder(File.ReadAllText(specificationPath));
+                    if (this.parameters.Logger != null)
+                    {
+                        this.parameters.Logger.LogAsync("Parsing specification file: " + specificationPath);
+                    }
+                    this.currentModule.LoadMetadataFromSpecification(jsonFinder);
                 }
             }
 
-            if (this.Output is JsonRpcPipe)
+            this.currentModule.CompleteMetadataLoad();
+
+            // For JSON-RPC pipe input/output, add Newtonsoft.Json converters
+            Newtonsoft.Json.JsonSerializerSettings inputSerializerSettings = null;
+            if (this.Input is JsonRpcPipe)
             {
-                JsonRpcPipe jsonRpcPipe = (JsonRpcPipe)this.Output;
+                JsonRpcPipe jsonRpcPipe = (JsonRpcPipe)this.Input;
+                inputSerializerSettings = jsonRpcPipe.JsonSerializerSettings;
                 new LiveTestRequestConverter(this.currentModule).RegisterSelf(jsonRpcPipe.JsonSerializerSettings);
                 if (this.parameters.Logger != null)
                 {
@@ -121,21 +133,17 @@ public async Task RunAsync()
                 }
             }
 
-            // Parse specifications/metadata files for extra information, e.g. parameter renaming
-            if (this.parameters.SpecificationPaths != null)
+            if (this.Output is JsonRpcPipe)
             {
-                foreach (string specificationPath in this.parameters.SpecificationPaths)
+                JsonRpcPipe jsonRpcPipe = (JsonRpcPipe)this.Output;
+                // Double check this is a different object than the input pipe, if any.
+                if (inputSerializerSettings == null || inputSerializerSettings != jsonRpcPipe.JsonSerializerSettings)
                 {
+                    new LiveTestRequestConverter(this.currentModule).RegisterSelf(jsonRpcPipe.JsonSerializerSettings);
                     if (this.parameters.Logger != null)
                     {
-                        this.parameters.Logger.LogAsync("Loading specification file: " + specificationPath);
+                        this.parameters.Logger.JsonSerializerSettings = jsonRpcPipe.JsonSerializerSettings;
                     }
-                        Json.JsonPathFinder jsonFinder = new Json.JsonPathFinder(File.ReadAllText(specificationPath));
-                        if (this.parameters.Logger != null)
-                        {
-                            this.parameters.Logger.LogAsync("Parsing specification file: " + specificationPath);
-                        }
-                        this.currentModule.LoadMetadataFromSpecification(jsonFinder);
                 }
             }
 
@@ -190,7 +198,8 @@ public async Task RunAsync()
                                     }
 
                                     response = msg.MakeResponse(exRequest, InternalError);
-                                } finally
+                                }
+                                finally
                                 {
                                     if (response != null)
                                     {
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs
index f801b03..95519cb 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs
@@ -34,11 +34,11 @@ public CompositeLogger AddLogger(Logger logger)
         /// Log a single message to output pipe.
         /// </summary>
         /// <param name="message">Message to log.</param>
-        public override void Log(string message)
+        public override void Log(string message, params object[] args)
         {
             foreach (Logger logger in this.InternalLoggers)
             {
-                logger.Log(message);
+                logger.Log(message, args);
             }
         }
 
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/Logger.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/Logger.cs
index 894f84f..7d3a4f6 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/Logger.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/Logger.cs
@@ -35,11 +35,17 @@ public Logger(IOutputPipe stdout, IOutputPipe stderr, bool timestamp = true, boo
         /// Log a single message to output pipe.
         /// </summary>
         /// <param name="message">Message to log.</param>
-        public virtual void Log(string message)
+        public virtual void Log(string message, params object[] args)
         {
             if (this.stdout != null)
             {
-                this.stdout.WriteLine(FormatMessage(message, "info"));
+                string msg = message;
+                if (args != null && args.Length > 0)
+                {
+                    msg = String.Format(message, args);
+                }
+
+                this.stdout.WriteLine(FormatMessage(msg, "info"));
             }
         }
 
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/AzurePageType.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/AzurePageType.cs
new file mode 100644
index 0000000..f5c61ac
--- /dev/null
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/AzurePageType.cs
@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Licensed under the MIT license.
+namespace PSSwagger.LTF.Lib.Models
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+
+    /// <summary>
+    /// Wraps a Page object used by Azure REST.
+    /// </summary>
+    public class AzurePageType
+    {
+        private Type pageType;
+        private Type itemsListType;
+        private PropertyInfo nextPageLinkInfo;
+        private PropertyInfo itemsInfo;
+
+        /// <summary>
+        /// Gets or sets the next link for the page.
+        /// </summary>
+        public string NextLink { get; set; }
+
+        /// <summary>
+        /// Gets the list of page items.
+        /// </summary>
+        public IList<object> Items { get; private set; }
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="genericPageType">Type of page.</param>
+        /// <param name="itemsType">Type of items in page.</param>
+        /// <param name="nextLinkPropertyName">Case-insensitive name of the property containing next link.</param>
+        /// <param name="itemsPropertyName">Case-insensitive name of the property containing the list of page items.</param>
+        public AzurePageType(Type genericPageType, Type itemsType)
+        {
+            this.pageType = genericPageType.MakeGenericType(itemsType);
+            this.itemsListType = typeof(List<>).MakeGenericType(itemsType);
+            this.Items = new List<object>();
+            this.nextPageLinkInfo = this.pageType.GetProperties().Where(pi => pi.Name.Equals("NextPageLink", StringComparison.OrdinalIgnoreCase)).Single();
+            this.itemsInfo = this.pageType.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance).Where(pi => pi.Name.Equals("Items", StringComparison.OrdinalIgnoreCase)).Single();
+        }
+
+        public object GetPage()
+        {
+            object page = Activator.CreateInstance(this.pageType);
+            this.nextPageLinkInfo.SetValue(page, this.NextLink);
+            IList pageItems = (IList)Activator.CreateInstance(this.itemsListType);
+            foreach (object item in this.Items)
+            {
+                pageItems.Add(item);
+            }
+
+            this.itemsInfo.SetValue(page, pageItems);
+            return page;
+        }
+    }
+}
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/GeneratedModule.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/GeneratedModule.cs
index c4971e6..fab5abe 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/GeneratedModule.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/GeneratedModule.cs
@@ -8,10 +8,14 @@ namespace PSSwagger.LTF.Lib.Models
     using Json;
     using Logging;
     using Messages;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Serialization;
+    using PostProcessors;
     using System;
     using System.Collections.Generic;
     using System.Globalization;
     using System.Linq;
+    using System.Reflection;
 
     /// <summary>
     /// Contains metadata for a generated module being tested.
@@ -19,6 +23,7 @@ namespace PSSwagger.LTF.Lib.Models
     public class GeneratedModule
     {
         private IRunspaceManager runspace;
+        private Dictionary<string, RuntimeTypeData> definitionsCache;
 
         public string ModulePath { get; set; }
 
@@ -33,197 +38,531 @@ public GeneratedModule(IRunspaceManager runspace)
             this.runspace = runspace;
             this.RequiredModules = new List<GeneratedModule>();
             this.Operations = new Dictionary<string, OperationData>();
+            this.definitionsCache = new Dictionary<string, RuntimeTypeData>();
         }
 
         public virtual void LoadMetadataFromSpecification(JsonPathFinder jsonPathFinder)
         {
-            // 1. Find x-ms-client-name directly under path
-            JsonQueryBuilder findNameUnderPath = new JsonQueryBuilder().Property("paths").RecursiveDescent().Property("x-ms-client-name");
-            IEnumerable<JsonPathFinder> findResults = jsonPathFinder.Find(findNameUnderPath);
-            if (findResults != null)
+            Log("Begin loading metadata from specification.");
+            // 1. Parse definitions into RuntimeTypeData's
+            JsonPathFinder definitionsNode = jsonPathFinder.Find(new JsonQueryBuilder().Property("definitions")).SingleOrDefault();
+            if (definitionsNode != null)
             {
-                foreach (JsonPathFinder node in findResults)
+                foreach (JsonPathFinder definitionContainerNode in definitionsNode.Children())
                 {
-                    Log("Found x-ms-client-name under paths: " + node);
-                    JsonPathFinder parameterNode = node.Parent.Parent;
-                    string jsonName = parameterNode.Find("name").Single().GetValue<string>().ToLowerInvariant();
-                    string parameterName = node.GetValue<string>().ToLowerInvariant();
-                    JsonPathFinder operationNode = parameterNode.Parent.Parent.Parent;
-                    JsonPathFinder operationIdNode = operationNode.Find("operationId").SingleOrDefault();
-                    if (operationIdNode != null)
+                    JsonPathFinder definitionNode = definitionContainerNode.OpenContainer();
+                    string definitionPath = definitionNode.Path;
+                    this.definitionsCache[definitionPath] = GetRuntimeTypeDataFromDefinition(definitionPath, definitionNode, this.definitionsCache, jsonPathFinder);
+                }
+            }
+
+            // 2. Get ParameterData from global parameters
+            JsonPathFinder globalParametersNode = jsonPathFinder.Find("parameters").SingleOrDefault();
+            Dictionary<string, Dictionary<string, ParameterData>> globalParameterCache = new Dictionary<string, Dictionary<string, ParameterData>>();
+            if (globalParametersNode != null)
+            {
+                foreach (JsonPathFinder globalParameterContainerNode in globalParametersNode.Children())
+                {
+                    JsonPathFinder globalParameter = globalParameterContainerNode.Children().First();
+                    string parameterPath = globalParameter.Path;
+                    globalParameterCache[parameterPath] = GetParameterMetadata(parameterPath, globalParameter, this.definitionsCache, globalParameterCache, jsonPathFinder);
+                }
+            }
+
+            // 3. Parse operations
+            ParseOperationsForMetadata(jsonPathFinder, this.definitionsCache, globalParameterCache);
+            
+            Log("Finished loading metadata from specification.");
+        }
+
+        /// <summary>
+        /// Runs all operations that need to take place after all metadata is loaded from all specifications.
+        /// </summary>
+        public void CompleteMetadataLoad()
+        {
+            foreach (ParameterData parameterData in this.Operations.Values.SelectMany(od => od.Parameters.Values))
+            {
+                // Top-level parameters should have type filled in
+                CompleteRuntimeDataType(parameterData.Type);
+            }
+
+            foreach (OperationData data in this.Operations.Values.Where(od => od.ResponseType != null))
+            {
+                // Make sure each response is properly merged
+                data.ResponseType.Complete();
+
+                // Then fill in subtypes
+                CompleteRuntimeDataType(data.ResponseType.TypeData);
+
+                // Create AzurePagePostProcessor if required
+                if (data.ResponseType.PageType != null)
+                {
+                    data.PostProcessors.Add(new AzurePagePostProcessor(new AzurePageType(data.ResponseType.PageType, data.ResponseType.TypeData.Type)));
+                }
+            }
+        }
+
+        private void CompleteRuntimeDataType(RuntimeTypeData data)
+        {
+            // At this point, data should have its Type filled in. In case it isn't, let's let an exception bubble up as an error
+            Type netType = data.Type;
+            Dictionary<string, Type> propertyTypes = new Dictionary<string, Type>();
+            foreach (PropertyInfo pi in netType.GetProperties())
+            {
+                propertyTypes[pi.Name.ToLowerInvariant()] = pi.PropertyType;
+            }
+
+            foreach (string propertyName in data.Properties.Keys)
+            {
+                ParameterData propertyData = data.Properties[propertyName];
+                if (propertyData.Type != null)
+                {
+                    // Sometimes the Name property isn't set - propertyName is correct in this case
+                    if (String.IsNullOrEmpty(propertyData.Name))
+                    {
+                        propertyData.Name = propertyName;
+                    }
+
+                    RuntimeTypeData propertyTypeData = propertyData.Type;
+                    if (propertyTypeData.Type == null)
                     {
-                        string operationId = operationIdNode.GetValue<string>().ToLowerInvariant();
-                        
-                        if (this.Operations.ContainsKey(operationId) && this.Operations[operationId].Parameters.ContainsKey(parameterName))
+                        // Find the type of this property
+                        if (propertyTypes.ContainsKey(propertyName))
                         {
-                            Log(String.Format(CultureInfo.CurrentCulture, "Mapping PowerShell parameter '{0}' to JSON property '{1}' for operation '{2}'", parameterName, jsonName, operationId));
-                            this.Operations[operationId].Parameters[parameterName].JsonName = jsonName;
+                            propertyTypeData.Type = propertyTypes[propertyName];
+                            // Recursively fill in the properties of this type
+                            CompleteRuntimeDataType(propertyTypeData);
                         }
-                    } else
+                    }
+                }
+            }
+        }
+
+        private void ParseOperationsForMetadata(JsonPathFinder rootDoc, Dictionary<string, RuntimeTypeData> definitionsCache, Dictionary<string, Dictionary<string, ParameterData>> parameterCache)
+        {
+            // Find each path item
+            JsonPathFinder paths = rootDoc.Find("paths").SingleOrDefault();
+            if (paths != null)
+            {
+                foreach (JsonPathFinder pathItemNode in paths.Children())
+                {
+                    ParsePathItemForMetadata(pathItemNode.OpenContainer(), definitionsCache, parameterCache, rootDoc);
+                }
+            }
+
+            JsonPathFinder extendedPaths = rootDoc.Find("x-ms-paths").SingleOrDefault();
+            if (extendedPaths != null)
+            {
+                foreach (JsonPathFinder pathItemNode in extendedPaths.Children())
+                {
+                    ParsePathItemForMetadata(pathItemNode.OpenContainer(), definitionsCache, parameterCache, rootDoc);
+                }
+            }
+        }
+
+        private void ParsePathItemForMetadata(JsonPathFinder pathItem, Dictionary<string, RuntimeTypeData> definitionsCache, Dictionary<string, Dictionary<string, ParameterData>> parameterCache, JsonPathFinder rootDoc)
+        {
+            // Parse path item level parameters first
+            JsonPathFinder pathLevelParameters = pathItem.Find(new JsonQueryBuilder().Property("parameters")).SingleOrDefault();
+            List<Dictionary<string, ParameterData>> pathLevelParameterList = new List<Dictionary<string, ParameterData>>();
+            if (pathLevelParameters != null)
+            {
+                foreach (JsonPathFinder parameterNode in pathLevelParameters.Children())
+                {
+                    Dictionary<string, ParameterData> parameters = GetParameterMetadata(parameterNode.Path, parameterNode, definitionsCache, parameterCache, rootDoc);
+                    pathLevelParameterList.Add(parameters);
+                }
+            }
+
+            // Parse each path (all children that are not keyed by "$ref" or "parameters")
+            foreach (JsonPathFinder operationContainerNode in pathItem.Children().Where(n => String.IsNullOrEmpty(n.Key) || (!n.Key.Equals("parameters") && !n.Key.Equals("$ref"))))
+            {
+                // Get parameter metadata from the operation
+                OperationData operationData = ParseOperationForMetadata(operationContainerNode.OpenContainer(), definitionsCache, parameterCache, rootDoc);
+                // Apply the path item level parameter data to this operation
+                if (operationData != null)
+                {
+                    Log(String.Format(CultureInfo.InvariantCulture, "Applying path level parameters to operation '{0}'", operationData.OperationId));
+                    foreach (Dictionary<string, ParameterData> parametersSet in pathLevelParameterList)
                     {
-                        // Path Item level parameter
-                        JsonPathFinder pathItemNode = parameterNode.Parent.Parent.Parent;
-                        foreach (JsonPathFinder opIdNodeFromPathItem in pathItemNode.Find(new JsonQueryBuilder().RecursiveDescent().Property("operationId")))
+                        foreach (string parameterName in parametersSet.Keys)
                         {
-                            string operationId = opIdNodeFromPathItem.GetValue<string>().ToLowerInvariant();
-                            if (this.Operations.ContainsKey(operationId) && this.Operations[operationId].Parameters.ContainsKey(parameterName))
+                            if (operationData.Parameters.ContainsKey(parameterName.ToLowerInvariant()))
                             {
-                                Log(String.Format(CultureInfo.CurrentCulture, "Mapping PowerShell parameter '{0}' to JSON property '{1}' for operation '{2}'", parameterName, jsonName, operationId));
-                                this.Operations[operationId].Parameters[parameterName].JsonName = jsonName;
+                                Log(String.Format(CultureInfo.InvariantCulture, "Found parameter with name '{0}' and JSON name '{1}'", parameterName, parametersSet[parameterName].JsonName));
+                                operationData.Parameters[parameterName.ToLowerInvariant()].MergeWith(parametersSet[parameterName]);
                             }
                         }
                     }
                 }
             }
 
-            // 2. Find x-ms-client-name directly under x-ms-paths
-            JsonQueryBuilder findNameUnderExtendedPaths = new JsonQueryBuilder().Property("x-ms-paths").RecursiveDescent().Property("x-ms-client-name");
-            findResults = jsonPathFinder.Find(findNameUnderExtendedPaths);
-            if (findResults != null)
+            // TODO: Currently no support for path item using $ref
+        }
+
+        private OperationData ParseOperationForMetadata(JsonPathFinder path, Dictionary<string, RuntimeTypeData> definitionsCache, Dictionary<string, Dictionary<string, ParameterData>> parameterCache, JsonPathFinder rootDoc)
+        {
+            JsonPathFinder parametersNode = path.Find(new JsonQueryBuilder().Property("parameters")).SingleOrDefault();
+            JsonPathFinder operationIdNode = path.Find(new JsonQueryBuilder().Property("operationId")).SingleOrDefault();
+            if (operationIdNode == null)
+            {
+                return null;
+            }
+
+            string operationId = operationIdNode.GetValue<string>();
+            if (!this.Operations.ContainsKey(operationId.ToLowerInvariant()))
             {
-                foreach (JsonPathFinder node in findResults)
+                Log(String.Format(CultureInfo.InvariantCulture, "Skipping operation '{0}' because no matching command was found.", operationId));
+                return null;
+            }
+
+            OperationData operationData = this.Operations[operationId.ToLowerInvariant()];
+            Log(String.Format(CultureInfo.InvariantCulture, "Loading metadata for operation '{0}' and command '{1}'", operationId, operationData.Command));
+
+            if (parametersNode != null)
+            {
+                foreach (JsonPathFinder parameterNode in parametersNode.Children())
                 {
-                    Log("Found x-ms-client-name under x-ms-paths: " + node);
-                    JsonPathFinder parameterNode = node.Parent.Parent;
-                    string jsonName = parameterNode.Find("name").Single().GetValue<string>().ToLowerInvariant();
-                    JsonPathFinder operationNode = parameterNode.Parent.Parent.Parent;
-                    string operationId = operationNode.Find("operationId").Single().GetValue<string>().ToLowerInvariant();
-                    string parameterName = node.GetValue<string>().ToLowerInvariant();
-                    if (this.Operations.ContainsKey(operationId) && this.Operations[operationId].Parameters.ContainsKey(parameterName))
+                    Dictionary<string, ParameterData> parameters = GetParameterMetadata(parameterNode.Path, parameterNode, definitionsCache, parameterCache, rootDoc);
+                    foreach (string parameterName in parameters.Keys)
                     {
-                        Log(String.Format(CultureInfo.CurrentCulture, "Mapping PowerShell parameter '{0}' to JSON property '{1}' for operation '{2}'", parameterName, jsonName, operationId));
-                        this.Operations[operationId].Parameters[parameterName].JsonName = jsonName;
+                        if (operationData.Parameters.ContainsKey(parameterName.ToLowerInvariant()))
+                        {
+                            Log(String.Format(CultureInfo.InvariantCulture, "Found parameter with name '{0}' and JSON name '{1}'", parameterName, parameters[parameterName].JsonName));
+                            operationData.Parameters[parameterName.ToLowerInvariant()].MergeWith(parameters[parameterName]);
+                        }
                     }
                 }
             }
 
-            // 3. Find x-ms-client-flatten under paths and x-ms-paths
-            JsonQueryBuilder schemaRef = new JsonQueryBuilder().Property("schema").Property("$ref");
-            JsonQueryBuilder findFlattenUnderPaths = new JsonQueryBuilder().Property("paths").RecursiveDescent().Property("x-ms-client-flatten");
-            findResults = jsonPathFinder.Find(findFlattenUnderPaths);
-            if (findResults != null)
+            // Find the first response in the [200-299] range, as that's all PSSwagger supports right now
+            JsonPathFinder responsesNode = path.Find(new JsonQueryBuilder().Property("responses")).SingleOrDefault();
+            string responseDefinitionPath = null;
+            if (responsesNode != null && operationData.ResponseType != null)
             {
-                foreach (JsonPathFinder node in findResults)
+                foreach (JsonPathFinder response in responsesNode.Children())
                 {
-                    if (!node.GetValue<bool>())
+                    int statusCode;
+                    if (Int32.TryParse(response.Key, out statusCode) && statusCode >= 200 && statusCode <= 299)
                     {
-                        continue;
+                        // For now we only support ref'd schema - need to fix that
+                        JsonPathFinder schemaRefNode = response.Find(new JsonQueryBuilder().RecursiveDescent().Property("$ref")).SingleOrDefault();
+                        if (schemaRefNode != null)
+                        {
+                            responseDefinitionPath = schemaRefNode.GetValue<string>();
+                            string definitionPathCaseInsensitive = responseDefinitionPath.ToLowerInvariant();
+                            if (definitionsCache.ContainsKey(definitionPathCaseInsensitive))
+                            {
+                                operationData.ResponseType.SpecificationData.Add(definitionsCache[definitionPathCaseInsensitive]);
+                                break;
+                            }
+                        }
                     }
-                    JsonPathFinder parameterNode = node.Parent.Parent;
-                    string definitionPath = parameterNode.Find(schemaRef).Single().GetValue<string>();
-                    JsonPathFinder operationNode = parameterNode.Parent.Parent.Parent;
-                    JsonPathFinder operationIdNode = operationNode.Find("operationId").SingleOrDefault();
-                    if (operationIdNode != null)
+                }
+            }
+
+            // Check for x-ms-pageable and set the page type if a response type exists
+            JsonPathFinder pageableExtension = path.Find(new JsonQueryBuilder().Property("x-ms-pageable")).SingleOrDefault();
+            if (pageableExtension != null && operationData.ResponseType != null)
+            {
+                string nextLinkJsonName = "nextLink";
+                string itemsJsonName = "value";
+                JsonPathFinder nextLinkName = pageableExtension.Find(new JsonQueryBuilder().RecursiveDescent().Property("nextLinkName")).SingleOrDefault();
+                JsonPathFinder itemName = pageableExtension.Find(new JsonQueryBuilder().RecursiveDescent().Property("itemName")).SingleOrDefault();
+                if (nextLinkName != null)
+                {
+                    nextLinkJsonName = nextLinkName.GetValue<string>();
+                }
+
+                if (itemName != null)
+                {
+                    itemsJsonName = itemName.GetValue<string>();
+                }
+
+                // Assuming the module is already loaded, find the correct .NET type for the Page
+                foreach (Type candidateType in AppDomain.CurrentDomain.GetAssemblies().SelectMany(asm => asm.GetTypes()))
+                {
+                    PropertyInfo itemsProperty = candidateType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(pi => pi.Name.Equals("Items")).FirstOrDefault();
+                    PropertyInfo nextPageLinkProperty = candidateType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(pi => pi.Name.Equals("NextPageLink")).FirstOrDefault();
+                    bool candidate = true;
+                    if (itemsProperty != null)
                     {
-                        string operationId = operationIdNode.GetValue<string>().ToLowerInvariant();
+                        JsonPropertyAttribute jsonPropertyAttribute = (JsonPropertyAttribute)itemsProperty.GetCustomAttribute(typeof(JsonPropertyAttribute));
+                        if (jsonPropertyAttribute == null || !jsonPropertyAttribute.PropertyName.Equals(itemsJsonName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            candidate = false;
+                        }
+                    } else
+                    {
+                        candidate = false;
+                    }
 
-                        if (this.Operations.ContainsKey(operationId))
+                    if (candidate && nextPageLinkProperty != null)
+                    {
+                        JsonPropertyAttribute jsonPropertyAttribute = (JsonPropertyAttribute)nextPageLinkProperty.GetCustomAttribute(typeof(JsonPropertyAttribute));
+                        if (jsonPropertyAttribute == null || !jsonPropertyAttribute.PropertyName.Equals(nextLinkJsonName, StringComparison.OrdinalIgnoreCase))
                         {
-                            JsonQueryBuilder definitionObject = new JsonQueryBuilder(definitionPath);
-                            JsonPathFinder objectNode = jsonPathFinder.Find(definitionObject).Single();
-                            LoadMetadataFromDefinitionNode(operationId, objectNode, jsonPathFinder);
+                            candidate = false;
                         }
                     }
                     else
                     {
-                        // Path Item level parameter
-                        JsonPathFinder pathItemNode = parameterNode.Parent.Parent.Parent;
-                        foreach (JsonPathFinder opIdNodeFromPathItem in pathItemNode.Find(new JsonQueryBuilder().RecursiveDescent().Property("operationId")))
+                        candidate = false;
+                    }
+
+                    if (candidate)
+                    {
+                        operationData.ResponseType.PageType = candidateType;
+                    }
+                }
+
+                // Find the correct specification data. If x-ms-pageable is used, the referenced output type is probably an array of items
+                // And PSSwagger will output the individual item type rather than the array type
+                // Set the output type of the individual item type
+                if (!String.IsNullOrEmpty(responseDefinitionPath))
+                {
+                    JsonPathFinder responseDefinitionNode = rootDoc.Find(new JsonQueryBuilder(responseDefinitionPath)).SingleOrDefault();
+                    if (responseDefinitionNode != null)
+                    {
+                        JsonPathFinder itemType = responseDefinitionNode.Find(new JsonQueryBuilder().RecursiveDescent().Property("$ref")).FirstOrDefault();
+                        if (itemType != null)
                         {
-                            string operationId = opIdNodeFromPathItem.GetValue<string>().ToLowerInvariant();
-                            if (this.Operations.ContainsKey(operationId))
-                            {
-                                JsonQueryBuilder definitionObject = new JsonQueryBuilder(definitionPath);
-                                JsonPathFinder objectNode = jsonPathFinder.Find(definitionObject).Single();
-                                LoadMetadataFromDefinitionNode(operationId, objectNode, jsonPathFinder);
-                            }
+                            operationData.ResponseType.SpecificationData.Add(definitionsCache[itemType.GetValue<string>().ToLowerInvariant()]);
                         }
                     }
                 }
             }
 
-            JsonQueryBuilder findFlattenUnderExtendedPaths = new JsonQueryBuilder().Property("x-ms-paths").RecursiveDescent().Property("x-ms-client-flatten");
-            findResults = jsonPathFinder.Find(findFlattenUnderExtendedPaths);
-            if (findResults != null)
+            return operationData;
+        }
+
+        private Dictionary<string, ParameterData> GetParameterMetadata(string parameterPath, JsonPathFinder parameter, Dictionary<string, RuntimeTypeData> definitionsCache, Dictionary<string, Dictionary<string, ParameterData>> parameterCache, JsonPathFinder rootDoc)
+        {
+            if (parameterCache.ContainsKey(parameterPath))
+            {
+                // We've already transformed this parameter into one or more parameters and found the correct module name
+                return parameterCache[parameterPath];
+            }
+
+            Dictionary<string, ParameterData> ret = new Dictionary<string, ParameterData>();
+            parameterCache[parameterPath] = ret;
+            // 1. Check if it's a ref
+            JsonPathFinder refNode = parameter.Find(new JsonQueryBuilder().Property("$ref")).SingleOrDefault();
+            if (refNode != null)
+            {
+                // A direct ref should reference a parameter object
+                string refParameterPath = refNode.GetValue<string>();
+                return GetParameterMetadata(refParameterPath.ToLowerInvariant(), rootDoc.Find(new JsonQueryBuilder(refParameterPath)).Single(), definitionsCache, parameterCache, rootDoc);
+            }
+            else
             {
-                foreach (JsonPathFinder node in findResults)
+                // 2. Get the name and jsonName
+                string jsonName = String.Empty;
+                string clientName = String.Empty;
+                JsonPathFinder jsonNameNode = parameter.Find(new JsonQueryBuilder().Property("name")).SingleOrDefault();
+                JsonPathFinder clientNameNode = parameter.Find(new JsonQueryBuilder().Property("x-ms-client-name")).SingleOrDefault();
+                if (jsonNameNode != null)
                 {
-                    if (!node.GetValue<bool>())
-                    {
-                        continue;
-                    }
-                    JsonPathFinder parameterNode = node.Parent.Parent;
-                    string definitionPath = parameterNode.Find(schemaRef).Single().GetValue<string>();
-                    JsonPathFinder operationNode = parameterNode.Parent.Parent.Parent;
-                    JsonPathFinder operationIdNode = operationNode.Find("operationId").SingleOrDefault();
-                    if (operationIdNode != null)
-                    {
-                        string operationId = operationIdNode.GetValue<string>().ToLowerInvariant();
+                    jsonName = jsonNameNode.GetValue<string>().ToLowerInvariant();
+                }
+
+                if (clientNameNode != null)
+                {
+                    clientName = clientNameNode.GetValue<string>().ToLowerInvariant();
+                }
 
-                        if (this.Operations.ContainsKey(operationId))
+                // 2. Check if it's a flatten
+                JsonPathFinder flattenNode = parameter.Find(new JsonQueryBuilder().Property("x-ms-client-flatten")).SingleOrDefault();
+                JsonPathFinder schemaRefNode = parameter.Find(new JsonQueryBuilder().RecursiveDescent().Property("$ref")).SingleOrDefault();
+                if (flattenNode != null)
+                {
+                    // Get the ref node under the schema node - using recursive descent from the parameter node should work
+                    // This should be a definitions object
+                    string definitionPath = schemaRefNode.GetValue<string>();
+                    RuntimeTypeData definitionData = definitionsCache[definitionPath];
+                    // Don't think there will be a flatten of an object that's just an array?
+                    foreach (string propertyName in definitionData.Properties.Keys)
+                    {
+                        ParameterData data = definitionData.Properties[propertyName];
+                        if (!String.IsNullOrEmpty(data.Name))
                         {
-                            JsonQueryBuilder definitionObject = new JsonQueryBuilder(definitionPath);
-                            JsonPathFinder objectNode = jsonPathFinder.Find(definitionObject).Single();
-                            LoadMetadataFromDefinitionNode(operationId, objectNode, jsonPathFinder);
+                            ret[data.Name] = data;
                         }
-                    }
-                    else
-                    {
-                        // Path Item level parameter
-                        JsonPathFinder pathItemNode = parameterNode.Parent.Parent.Parent;
-                        foreach (JsonPathFinder opIdNodeFromPathItem in pathItemNode.Find(new JsonQueryBuilder().RecursiveDescent().Property("operationId")))
+                        else
                         {
-                            string operationId = opIdNodeFromPathItem.GetValue<string>().ToLowerInvariant();
-                            if (this.Operations.ContainsKey(operationId))
-                            {
-                                JsonQueryBuilder definitionObject = new JsonQueryBuilder(definitionPath);
-                                JsonPathFinder objectNode = jsonPathFinder.Find(definitionObject).Single();
-                                LoadMetadataFromDefinitionNode(operationId, objectNode, jsonPathFinder);
-                            }
+                            ret[data.JsonName] = data;
                         }
                     }
+                } else
+                {
+                    // 3. Just a regular parameter - check if it defines a definition as the type
+                    ParameterData data = new ParameterData();
+                    data.Name = clientName;
+                    data.JsonName = jsonName;
+                    if (schemaRefNode != null)
+                    {
+                        string definitionPath = schemaRefNode.GetValue<string>().ToLowerInvariant();
+                        data.Type = definitionsCache[definitionPath];
+                    } else
+                    {
+                        // Type with no properties, and the Type itself will be filled in later
+                        data.Type = new RuntimeTypeData();
+                    }
+
+                    if (!String.IsNullOrEmpty(clientName))
+                    {
+                        ret[clientName] = data;
+                    } else
+                    {
+                        ret[jsonName] = data;
+                    }
                 }
             }
 
-            // 4. Find all ref'd parameters
-            JsonQueryBuilder findRefParameters = new JsonQueryBuilder().Property("paths").Any().Any().Property("parameters").ArrayIndex(new JsonQueryBuilder().Filter(new JsonQueryBuilder().HasProperty("$ref")));
-            findResults = jsonPathFinder.Find(findRefParameters);
-            if (findResults != null)
+            return ret;
+        }
+
+        private RuntimeTypeData GetRuntimeTypeDataFromDefinition(string definitionName, JsonPathFinder definitionNode, Dictionary<string, RuntimeTypeData> cache, JsonPathFinder rootDoc)
+        {
+            // 0. Check if the type already exists
+            if (cache.ContainsKey(definitionName))
+            {
+                return cache[definitionName];
+            }
+
+            RuntimeTypeData data = new RuntimeTypeData();
+            cache[definitionName] = data;
+            // 1. Get properties node
+            JsonPathFinder propertiesNode = definitionNode.Find(new JsonQueryBuilder().Property("properties")).SingleOrDefault();
+            if (propertiesNode != null)
             {
-                foreach (JsonPathFinder node in findResults)
+                // 2. Read flat properties
+                foreach (JsonPathFinder propertyContainerNode in propertiesNode.Children())
                 {
-                    JsonPathFinder operationNode = node.Parent.Parent.Parent;
-                    string operationId = operationNode.Find("operationId").Single().GetValue<string>().ToLowerInvariant();
-                    JsonPathFinder globalParameter = jsonPathFinder.Find(new JsonQueryBuilder(node.Find("$ref").Single().GetValue<string>())).Single();
+                    JsonPathFinder propertyNode = propertyContainerNode.OpenContainer();
+                    // First things first - check if the property is renamed
+                    JsonPathFinder clientNameNode = propertyNode.Find(new JsonQueryBuilder().Property("x-ms-client-name")).SingleOrDefault();
+                    string clientName = String.Empty;
+                    if (clientNameNode != null)
+                    {
+                        clientName = clientNameNode.GetValue<string>().ToLowerInvariant();
+                    }
 
-                    // Check for x-ms-client-name
-                    JsonPathFinder globalParameterClientName = globalParameter.Find("x-ms-client-name").SingleOrDefault();
-                    if (globalParameterClientName != null)
+                    string jsonName = propertyNode.Key.ToLowerInvariant();
+                    string rawJsonName = propertyNode.Key;
+                    // 5 cases:
+                    //  1: Property contains a $ref node AND property contains an x-ms-client-flatten node
+                    //  2: Property contains only a $ref node
+                    //  3: Property is of type object and contains additionalProperties (not sure how to handle this yet)
+                    //  4: Property is of type array (decode the individual items type)
+                    //  5: Property is a simple property
+                    JsonPathFinder refNode = propertyNode.Find(new JsonQueryBuilder().Property("$ref")).SingleOrDefault();
+                    JsonPathFinder flattenNode = propertyNode.Find(new JsonQueryBuilder().Property("x-ms-client-flatten")).SingleOrDefault();
+                    JsonPathFinder typeNode = propertyNode.Find(new JsonQueryBuilder().Property("type")).SingleOrDefault();
+                    JsonPathFinder additionalPropertiesNode = propertyNode.Find(new JsonQueryBuilder().Property("additionalProperties")).SingleOrDefault();
+                    JsonPathFinder arrayItemsRefNode = propertyNode.Find(new JsonQueryBuilder().Property("items").Property("$ref")).SingleOrDefault();
+                    JsonPathFinder propertiesSubNode = propertyNode.Find(new JsonQueryBuilder().Property("properties")).SingleOrDefault();
+                    if (refNode != null)
                     {
-                        string parameterName = globalParameterClientName.GetValue<string>().ToLowerInvariant();
-                        Log("Found x-ms-client-name under global parameter: " + parameterName);
-                        string jsonName = globalParameter.Find("name").Single().GetValue<string>().ToLowerInvariant();
-                        if (this.Operations.ContainsKey(operationId) && this.Operations[operationId].Parameters.ContainsKey(parameterName))
+                        JsonPathFinder subDefinition = rootDoc.Find(new JsonQueryBuilder(refNode.GetValue<string>())).Single();
+                        RuntimeTypeData referencedTypeData = GetRuntimeTypeDataFromDefinition(subDefinition.Path, subDefinition, cache, rootDoc);
+                        if (flattenNode != null && flattenNode.GetValue<bool>())
+                        {
+                            // Push the properties of the referenced type to this type
+                            // If it's flattened, the jsonName should actually be flatJsonName
+                            foreach (string propertyName in referencedTypeData.Properties.Keys)
+                            {
+                                data.Properties[propertyName] = referencedTypeData.Properties[propertyName].Clone();
+                                data.Properties[propertyName].SubNodeName = "properties";
+                            }
+                        }
+                        else
                         {
-                            Log(String.Format(CultureInfo.CurrentCulture, "Mapping PowerShell parameter '{0}' to JSON property '{1}' for operation '{2}'", parameterName, jsonName, operationId));
-                            this.Operations[operationId].Parameters[parameterName].JsonName = jsonName;
+                            // The referenced type is simply the type of this property
+                            data.Properties[jsonName] = new ParameterData()
+                            {
+                                Name = clientName,
+                                JsonName = jsonName,
+                                RawJsonName = rawJsonName,
+                                Type = referencedTypeData
+                            };
                         }
                     }
+                    else if (typeNode != null && typeNode.GetValue<string>().ToLowerInvariant().Equals("object") && additionalPropertiesNode != null)
+                    {
+                        // No converter required, this will probably be a Dictionary<string, something>
+                        data.Properties[jsonName] = new ParameterData()
+                        {
+                            Name = clientName,
+                            JsonName = jsonName,
+                            RawJsonName = rawJsonName
+                        };
 
-                    // Check for x-ms-client-flatten
-                    JsonPathFinder globalParameterClientFlatten = globalParameter.Find("x-ms-client-flatten").SingleOrDefault();
-                    if (globalParameterClientFlatten != null)
+                        // TODO: Support complex object as the additionalProperties type. Don't have a good example if this yet...
+                    }
+                    else if (typeNode != null && typeNode.GetValue<string>().ToLowerInvariant().Equals("array"))
                     {
-                        string definitionPath = globalParameter.Find(schemaRef).Single().GetValue<string>();
-                        if (this.Operations.ContainsKey(operationId))
+                        // No converter required
+                        data.Properties[jsonName] = new ParameterData()
+                        {
+                            Name = clientName,
+                            JsonName = jsonName,
+                            RawJsonName = rawJsonName
+                        };
+
+                        // When this is an array, we should add the type of the items in the array so that a converter is registered later
+                        if (arrayItemsRefNode != null)
                         {
-                            JsonQueryBuilder definitionObject = new JsonQueryBuilder(definitionPath);
-                            JsonPathFinder objectNode = jsonPathFinder.Find(definitionObject).Single();
-                            LoadMetadataFromDefinitionNode(operationId, objectNode, jsonPathFinder);
+                            JsonPathFinder subDefinition = rootDoc.Find(new JsonQueryBuilder(arrayItemsRefNode.GetValue<string>())).Single();
+                            data.Properties[jsonName].Type = new RuntimeTypeData();
+                            data.Properties[jsonName].Type.CollectionTypes.Add(GetRuntimeTypeDataFromDefinition(subDefinition.Path, subDefinition, cache, rootDoc));
                         }
                     }
+                    else if (propertiesSubNode != null)
+                    {
+                        // Not sure what to do with definition name yet
+                        // The actual Type of the anonymous type will be filled in by postprocessing
+                        // TODO: The properties of the subtype might be prefixed with "properties."
+                        data.Properties[jsonName] = new ParameterData()
+                        {
+                            Name = clientName,
+                            JsonName = jsonName,
+                            RawJsonName = rawJsonName,
+                            Type = GetRuntimeTypeDataFromDefinition(Guid.NewGuid().ToString(), propertyNode, cache, rootDoc)
+                        };
+                    }
+                    else
+                    {
+                        // The last case should be the case of a simple property - assign the name and jsonName and let the type be inferred later
+                        data.Properties[jsonName] = new ParameterData()
+                        {
+                            Name = clientName,
+                            JsonName = jsonName,
+                            RawJsonName = rawJsonName,
+                            Type = new RuntimeTypeData()
+                        };
+                    }
+                }
+            }
+
+            // 3. Read allOf node
+            JsonPathFinder allOfNode = definitionNode.Find(new JsonQueryBuilder().Property("allOf")).SingleOrDefault();
+            if (allOfNode != null)
+            {
+                // Get all $ref's
+                foreach (JsonPathFinder refNode in allOfNode.Find(new JsonQueryBuilder().RecursiveDescent().Property("$ref")))
+                {
+                    JsonPathFinder subDefinition = rootDoc.Find(new JsonQueryBuilder(refNode.GetValue<string>())).Single();
+                    RuntimeTypeData referencedTypeData = GetRuntimeTypeDataFromDefinition(subDefinition.Path, subDefinition, cache, rootDoc);
+                    // Push the properties of the referenced type to this type
+                    foreach (string propertyName in referencedTypeData.Properties.Keys)
+                    {
+                        data.Properties[propertyName] = referencedTypeData.Properties[propertyName];
+                    }
                 }
             }
+            
+            return data;
         }
 
         public virtual CommandExecutionResult ProcessRequest(LiveTestRequest request, LiveTestCredentialFactory credentialsFactory)
@@ -269,6 +608,12 @@ public virtual CommandExecutionResult ProcessRequest(LiveTestRequest request, Li
 
                 // Run the command
                 result = command.Invoke();
+
+                // Run post processors, if any
+                foreach (ICommandPostProcessor postProcessor in op.PostProcessors)
+                {
+                    result = postProcessor.Process(result);
+                }
             }
             else
             {
@@ -308,45 +653,6 @@ public virtual CommandExecutionResult Load(bool force = false)
             return command.Invoke();
         }
 
-        private void LoadMetadataFromDefinitionNode(string operationId, JsonPathFinder definitionNode, JsonPathFinder rootFinder)
-        {
-            JsonQueryBuilder findName = new JsonQueryBuilder().RecursiveDescent().Property("x-ms-client-name");
-            IEnumerable<JsonPathFinder> findResults = definitionNode.Find(findName);
-            if (findResults != null)
-            {
-                foreach (JsonPathFinder node in findResults)
-                {
-                    string jsonName = node.Key.ToLowerInvariant();
-                    string parameterName = node.GetValue<string>().ToLowerInvariant();
-                    Log("Found x-ms-client-name under definition property: " + parameterName);
-                    if (this.Operations.ContainsKey(operationId) && this.Operations[operationId].Parameters.ContainsKey(parameterName))
-                    {
-                        Log(String.Format(CultureInfo.CurrentCulture, "Mapping PowerShell parameter '{0}' to JSON property '{1}' for operation '{2}'", parameterName, jsonName, operationId));
-                        this.Operations[operationId].Parameters[parameterName].JsonName = jsonName;
-                    }
-                }
-            }
-
-            JsonQueryBuilder findFlatten = new JsonQueryBuilder().RecursiveDescent().Property("x-ms-client-flatten");
-            JsonQueryBuilder findRef = new JsonQueryBuilder().Property("$ref");
-            findResults = definitionNode.Find(findFlatten);
-            if (findResults != null)
-            {
-                foreach (JsonPathFinder node in findResults)
-                {
-                    if (!node.GetValue<bool>())
-                    {
-                        continue;
-                    }
-                    JsonPathFinder refNode = node.Parent.Parent.Find(findRef).Single();
-                    string definitionPath = refNode.GetValue<string>();
-                    JsonQueryBuilder definitionObject = new JsonQueryBuilder(definitionPath);
-                    JsonPathFinder objectNode = rootFinder.Find(definitionObject).Single();
-                    LoadMetadataFromDefinitionNode(operationId, objectNode, rootFinder);
-                }
-            }
-        }
-
         private void Log(string msg)
         {
             if (this.Logger != null)
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/OperationData.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/OperationData.cs
index 02bf89b..ffae2f0 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/OperationData.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/OperationData.cs
@@ -3,6 +3,7 @@
 // Licensed under the MIT license.
 namespace PSSwagger.LTF.Lib.Models
 {
+    using Interfaces;
     using System.Collections.Generic;
 
     /// <summary>
@@ -25,11 +26,23 @@ public class OperationData
         /// </summary>
         public Dictionary<string, ParameterData> Parameters { get; set; }
 
+        /// <summary>
+        /// Gets type data for the expected response Type, if any. PSSwagger currently picks the first response within the 200-299 status code range, if any.
+        /// </summary>
+        public ResponseTypeData ResponseType { get; set; }
+
+        /// <summary>
+        /// Gets the list of post processors.
+        /// </summary>
+        public IList<ICommandPostProcessor> PostProcessors { get; private set; }
+
         public OperationData(string operationId, string command)
         {
             this.Command = command;
             this.OperationId = operationId;
             this.Parameters = new Dictionary<string, ParameterData>();
+            this.ResponseType = null;
+            this.PostProcessors = new List<ICommandPostProcessor>();
         }
     }
 }
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/ParameterData.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/ParameterData.cs
index f35c0c2..37bcdd1 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/ParameterData.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/ParameterData.cs
@@ -18,9 +18,54 @@ public class ParameterData
         /// </summary>
         public string JsonName { get; set; }
 
+        /// <summary>
+        /// Gets or sets the JSON name used by the Azure C# SDK.
+        /// </summary>
+        public string SubNodeName { get; set; }
+
+        /// <summary>
+        /// Gets or sets the case-sensitive JSON name.
+        /// </summary>
+        public string RawJsonName { get; set; }
+
         /// <summary>
         /// Type of this parameter.
         /// </summary>
         public RuntimeTypeData Type { get; set; }
+
+        public void MergeWith(ParameterData newData)
+        {
+            if (!string.IsNullOrEmpty(newData.Name))
+            {
+                this.Name = newData.Name;
+            }
+
+            if (!string.IsNullOrEmpty(newData.JsonName))
+            {
+                this.JsonName = newData.JsonName;
+            }
+
+            if (newData.Type != null)
+            {
+                if (this.Type != null)
+                {
+                    this.Type.MergeWith(newData.Type);
+                } else
+                {
+                    this.Type = newData.Type;
+                }
+            }
+        }
+
+        public ParameterData Clone()
+        {
+            ParameterData data = new ParameterData();
+            data.Name = this.Name;
+            data.JsonName = this.JsonName;
+            data.SubNodeName = this.SubNodeName;
+            data.RawJsonName = this.RawJsonName;
+            data.Type = this.Type == null ? null : this.Type.Clone();
+            return data;
+        }
     }
 }
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/ResponseTypeData.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/ResponseTypeData.cs
new file mode 100644
index 0000000..5a6718d
--- /dev/null
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/ResponseTypeData.cs
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Licensed under the MIT license.
+namespace PSSwagger.LTF.Lib.Models
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Contains metadata for a single command output type.
+    /// </summary>
+    public class ResponseTypeData
+    {
+        /// <summary>
+        /// Gets or sets type data retrieved from specification(s).
+        /// </summary>
+        public IList<RuntimeTypeData> SpecificationData { get; set; }
+
+        /// <summary>
+        /// Gets or sets type data retrieved from the module.
+        /// </summary>
+        public RuntimeTypeData ModuleData { get; set; }
+
+        /// <summary>
+        /// Gets merged type data.
+        /// </summary>
+        public RuntimeTypeData TypeData { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the .NET type for the page container, if any.
+        /// </summary>
+        public Type PageType { get; set; }
+
+        public ResponseTypeData()
+        {
+            this.SpecificationData = new List<RuntimeTypeData>();
+        }
+
+        /// <summary>
+        /// Complete creation of this response type by merging all sources of data.
+        /// </summary>
+        public void Complete()
+        {
+            this.TypeData = this.ModuleData;
+            RuntimeTypeData specificationData = FindBestMatchingSpecification(this.ModuleData.Type);
+            if (specificationData != null)
+            {
+                this.TypeData.MergeWith(specificationData);
+            }
+        }
+
+        /// <summary>
+        /// Find the item in SpecificationData whose properties best match the given .NET type.
+        /// </summary>
+        private RuntimeTypeData FindBestMatchingSpecification(Type netType)
+        {
+            RuntimeTypeData bestMatch = null;
+            int bestMatchingPropertiesCount = 0;
+            Dictionary<string, System.Reflection.PropertyInfo> netProperties = new Dictionary<string, System.Reflection.PropertyInfo>();
+            foreach (System.Reflection.PropertyInfo pi in netType.GetProperties())
+            {
+                netProperties[pi.Name.ToLowerInvariant()] = pi;
+            }
+
+            foreach (RuntimeTypeData candidate in this.SpecificationData)
+            {
+                int matchingProperties = 0;
+                foreach (string propertyName in candidate.Properties.Keys)
+                {
+                    if (netProperties.ContainsKey(propertyName) && (candidate.Properties[propertyName].Type == null || candidate.Properties[propertyName].Type.Type == null || candidate.Properties[propertyName].Type.Type.Equals(netProperties[propertyName].PropertyType)))
+                    {
+                        matchingProperties++;
+                    }
+                }
+
+                if (bestMatch == null || bestMatchingPropertiesCount < matchingProperties)
+                {
+                    bestMatchingPropertiesCount = matchingProperties;
+                    bestMatch = candidate;
+                }
+            }
+
+            return bestMatch;
+        }
+    }
+}
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/RuntimeTypeData.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/RuntimeTypeData.cs
index 0ed9b82..004d893 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/RuntimeTypeData.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Models/RuntimeTypeData.cs
@@ -16,10 +16,15 @@ public class RuntimeTypeData
         /// </summary>
         public Type Type { get; set; }
 
+        /// <summary>
+        /// Type data for types used by collection types (e.g. System.Array).
+        /// </summary>
+        public IList<RuntimeTypeData> CollectionTypes { get; private set; }
+
         /// <summary>
         /// Properties of this type. Keyed on the JSON representation.
         /// </summary>
-        public IDictionary<string, ParameterData> Properties { get; private set; }
+        public IDictionary<string, ParameterData> Properties { get; set; }
 
         public RuntimeTypeData() : this(null)
         {
@@ -29,6 +34,42 @@ public RuntimeTypeData(Type t)
         {
             this.Properties = new Dictionary<string, ParameterData>();
             this.Type = t;
+            this.CollectionTypes = new List<RuntimeTypeData>();
+        }
+
+        public void MergeWith(RuntimeTypeData newData)
+        {
+            if (newData.Type != null)
+            {
+                this.Type = newData.Type;
+            }
+
+            if (newData.CollectionTypes != null)
+            {
+                this.CollectionTypes = newData.CollectionTypes;
+            }
+
+            if (newData.Properties != null)
+            {
+                this.Properties = newData.Properties;
+            }
+        }
+
+        public RuntimeTypeData Clone()
+        {
+            RuntimeTypeData data = new RuntimeTypeData();
+            data.Type = this.Type;
+            foreach (RuntimeTypeData d in this.CollectionTypes)
+            {
+                data.CollectionTypes.Add(d.Clone());
+            }
+
+            foreach (string key in this.Properties.Keys)
+            {
+                data.Properties[key] = this.Properties[key].Clone();
+            }
+
+            return data;
         }
     }
 }
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/PostProcessors/AzurePagePostProcessor.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/PostProcessors/AzurePagePostProcessor.cs
new file mode 100644
index 0000000..a60786f
--- /dev/null
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/PostProcessors/AzurePagePostProcessor.cs
@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Licensed under the MIT license.
+namespace PSSwagger.LTF.Lib.PostProcessors
+{
+    using PSSwagger.LTF.Lib.Interfaces;
+    using System;
+    using Models;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Transform the command result into a page of results.
+    /// </summary>
+    public class AzurePagePostProcessor : ICommandPostProcessor
+    {
+        private AzurePageType page;
+        public AzurePagePostProcessor(AzurePageType page)
+        {
+            this.page = page;
+        }
+
+        public CommandExecutionResult Process(CommandExecutionResult result)
+        {
+            if (result.HadErrors)
+            {
+                return result;
+            }
+
+            // Because PowerShell flattens all items, nextLinkName is always null
+            page.NextLink = null;
+            foreach (object resultItem in result.Results)
+            {
+                page.Items.Add(resultItem);
+            }
+
+            CommandExecutionResult newResult = new CommandExecutionResult(new List<object>() { page.GetPage() }, result.Errors, result.HadErrors);
+            return newResult;
+        }
+    }
+}
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/PowerShell/PowerShellRunspace.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/PowerShell/PowerShellRunspace.cs
index 1eb7c0f..f69ff1a 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/PowerShell/PowerShellRunspace.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/PowerShell/PowerShellRunspace.cs
@@ -75,7 +75,8 @@ public GeneratedModule GetModuleInfo(string modulePath)
                     requiredModuleInfo.ModulePath = requiredModule.Name;
                     module.RequiredModules.Add(requiredModuleInfo);
                 }
-            } else
+            }
+            else
             {
                 // Otherwise assume the input is a module name instead of a path and attempt a direct load
                 moduleName = modulePath;
@@ -106,10 +107,18 @@ public GeneratedModule GetModuleInfo(string modulePath)
             foreach (string entry in moduleInfo.ExportedFunctions.Keys)
             {
                 FunctionInfo commandInfo = moduleInfo.ExportedFunctions[entry] as FunctionInfo;
+                PSTypeName outputTypeName = null;
+                if (commandInfo.OutputType != null && commandInfo.OutputType.Count > 0)
+                {
+                    // For now PSSwagger only takes the first response
+                    outputTypeName = commandInfo.OutputType.First();
+                }
+
                 if (this.logger != null)
                 {
                     this.logger.LogAsync("Parsing command: " + entry);
                 }
+
                 if (commandInfo != null)
                 {
                     foreach (CommandParameterSetInfo parameterSet in commandInfo.ParameterSets)
@@ -127,6 +136,14 @@ public GeneratedModule GetModuleInfo(string modulePath)
                             operationData.Parameters.Add(parameterData.Name.ToLowerInvariant(), parameterData);
                         }
 
+                        if (outputTypeName != null)
+                        {
+                            operationData.ResponseType = new ResponseTypeData()
+                            {
+                                ModuleData = new RuntimeTypeData(outputTypeName.Type)
+                            };
+                        }
+
                         module.Operations[operationData.OperationId.ToLowerInvariant()] = operationData;
                     }
                 }
@@ -154,7 +171,8 @@ public CommandExecutionResult Invoke(object command)
                         if (fieldInfo != null && !(bool)fieldInfo.GetValue(psObj))
                         {
                             return psObj.ImmediateBaseObject;
-                        } else
+                        }
+                        else
                         {
                             return psObj;
                         }
@@ -164,7 +182,8 @@ public CommandExecutionResult Invoke(object command)
                     {
                         errors = pipeline.Error.ReadToEnd().AsEnumerable<object>();
                     }
-                } catch (Exception e)
+                }
+                catch (Exception e)
                 {
                     if (this.logger != null)
                     {
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/ServiceTracing/ClientRuntimeServiceTracer.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/ServiceTracing/ClientRuntimeServiceTracer.cs
index 09f2332..7c3001c 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/ServiceTracing/ClientRuntimeServiceTracer.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/ServiceTracing/ClientRuntimeServiceTracer.cs
@@ -48,7 +48,9 @@ public void Information(string message)
 
         public void ReceiveResponse(string invocationId, HttpResponseMessage response)
         {
-            if (this.invocationId.Equals(invocationId))
+            // InvocationId check is currently disabled due to the multi-request nature of some AutoRest functions
+            // This means that, for now, tracing is not thread safe
+            //if (this.invocationId.Equals(invocationId))
             {
                 if (this.logger != null)
                 {
@@ -61,7 +63,9 @@ public void ReceiveResponse(string invocationId, HttpResponseMessage response)
 
         public void SendRequest(string invocationId, HttpRequestMessage request)
         {
-            if (this.invocationId.Equals(invocationId))
+            // InvocationId check is currently disabled due to the multi-request nature of some AutoRest functions
+            // This means that, for now, tracing is not thread safe
+            //if (this.invocationId.Equals(invocationId))
             {
                 if (this.logger != null)
                 {
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/vs-csproj/PSSwagger.LTF.Lib.csproj b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/vs-csproj/PSSwagger.LTF.Lib.csproj
index e722f8a..ab9d0bb 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/vs-csproj/PSSwagger.LTF.Lib.csproj
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/vs-csproj/PSSwagger.LTF.Lib.csproj
@@ -91,6 +91,9 @@
     <Compile Include="..\Json\*.cs">
       <Link>Json\%(FileName).cs</Link>
     </Compile>
+    <Compile Include="..\PostProcessors\*.cs">
+      <Link>PostProcessors\%(FileName).cs</Link>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />
diff --git a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/GeneratedModuleTests.cs b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/GeneratedModuleTests.cs
index abf8984..0ed2123 100644
--- a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/GeneratedModuleTests.cs
+++ b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/GeneratedModuleTests.cs
@@ -269,28 +269,74 @@ public void ParameterRenamedUsingAutoRestExt()
             GeneratedModule expectedModule, testModule;
             GetLoadMetadataFromSpecificationTestData(out expectedModule, out testModule);
 
-            // Root document
-            MockJsonPathFinder rootFinder = new MockJsonPathFinder();
-            // Operation's "operationId" property
-            MockJsonPathFinder operationIdFinder = new MockJsonPathFinder();
-            operationIdFinder.ValueMock = "operationid";
-            // Operation node
-            MockJsonPathFinder operationFinder = new MockJsonPathFinder();
-            operationFinder.QueryMocks["operationId"] = new List<JsonPathFinder>() { operationIdFinder };
-            // Parameter's "name" property
-            MockJsonPathFinder parameterNameFinder = new MockJsonPathFinder();
-            parameterNameFinder.ValueMock = "nameFromSpec";
-            // Parameter node
-            MockJsonPathFinder parameterFinder = new MockJsonPathFinder();
-            parameterFinder.QueryMocks["name"] = new List<JsonPathFinder>() { parameterNameFinder };
-            parameterFinder.ParentMock = operationFinder.MakeDummyParent(2);
-            // Parameter's "x-ms-client-name" property
-            MockJsonPathFinder clientNameFinder = new MockJsonPathFinder();
-            clientNameFinder.ValueMock = "psParameterName";
-            clientNameFinder.ParentMock = parameterFinder.MakeDummyParent();
-
-            // The root will be queried for x-ms-client-name nodes
-            rootFinder.QueryMocks["paths..x-ms-client-name"] = new List<JsonPathFinder>() { clientNameFinder };
+            MockJsonPathFinder rootFinder = new MockJsonPathFinder()
+            {
+                KeyMock = "root",
+                QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                {
+                    { "paths", new List<JsonPathFinder>()
+                    {
+                        new MockJsonPathFinder()
+                        {
+                            KeyMock = "paths",
+                            ChildrenMocks = new List<JsonPathFinder>()
+                            {
+                                new MockJsonPathFinder()
+                                {
+                                    KeyMock = "pathItem",
+                                    ChildrenMocks = new List<JsonPathFinder>()
+                                    {
+                                        new MockJsonPathFinder()
+                                        {
+                                            KeyMock = "getOperation",
+                                            QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                            {
+                                                { "operationId", new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        ValueMock = "operationid"
+                                                    }
+                                                } },
+                                                { "parameters", new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        ChildrenMocks = new List<JsonPathFinder>()
+                                                        {
+                                                            new MockJsonPathFinder()
+                                                            {
+                                                                PathMock = "dummy",
+                                                                QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                                                {
+                                                                    { "name", new List<JsonPathFinder>()
+                                                                    {
+                                                                        new MockJsonPathFinder()
+                                                                        {
+                                                                            ValueMock = "nameFromSpec"
+                                                                        }
+                                                                    } },
+                                                                    { "x-ms-client-name", new List<JsonPathFinder>()
+                                                                    {
+                                                                        new MockJsonPathFinder()
+                                                                        {
+                                                                            ValueMock = "psParameterName"
+                                                                        }
+                                                                    } }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                } }
+                                            }
+                                        }.Container()
+                                    }
+                                }.Container()
+                            }
+                        }
+                    } }
+                }
+            };
 
             testModule.LoadMetadataFromSpecification(rootFinder);
 
@@ -303,28 +349,74 @@ public void ExtendedPathsParameterRenamedUsingAutoRestExt()
             GeneratedModule expectedModule, testModule;
             GetLoadMetadataFromSpecificationTestData(out expectedModule, out testModule);
 
-            // Root document
-            MockJsonPathFinder rootFinder = new MockJsonPathFinder();
-            // Operation's "operationId" property
-            MockJsonPathFinder operationIdFinder = new MockJsonPathFinder();
-            operationIdFinder.ValueMock = "operationid";
-            // Operation node
-            MockJsonPathFinder operationFinder = new MockJsonPathFinder();
-            operationFinder.QueryMocks["operationId"] = new List<JsonPathFinder>() { operationIdFinder };
-            // Parameter's "name" property
-            MockJsonPathFinder parameterNameFinder = new MockJsonPathFinder();
-            parameterNameFinder.ValueMock = "nameFromSpec";
-            // Parameter node
-            MockJsonPathFinder parameterFinder = new MockJsonPathFinder();
-            parameterFinder.QueryMocks["name"] = new List<JsonPathFinder>() { parameterNameFinder };
-            parameterFinder.ParentMock = operationFinder.MakeDummyParent(2);
-            // Parameter's "x-ms-client-name" property
-            MockJsonPathFinder clientNameFinder = new MockJsonPathFinder();
-            clientNameFinder.ValueMock = "psParameterName";
-            clientNameFinder.ParentMock = parameterFinder.MakeDummyParent();
-
-            // The root will be queried for x-ms-client-name nodes
-            rootFinder.QueryMocks["x-ms-paths..x-ms-client-name"] = new List<JsonPathFinder>() { clientNameFinder };
+            MockJsonPathFinder rootFinder = new MockJsonPathFinder()
+            {
+                KeyMock = "root",
+                QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                {
+                    { "x-ms-paths", new List<JsonPathFinder>()
+                    {
+                        new MockJsonPathFinder()
+                        {
+                            KeyMock = "x-ms-paths",
+                            ChildrenMocks = new List<JsonPathFinder>()
+                            {
+                                new MockJsonPathFinder()
+                                {
+                                    KeyMock = "pathItem",
+                                    ChildrenMocks = new List<JsonPathFinder>()
+                                    {
+                                        new MockJsonPathFinder()
+                                        {
+                                            KeyMock = "getOperation",
+                                            QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                            {
+                                                { "operationId", new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        ValueMock = "operationid"
+                                                    }
+                                                } },
+                                                { "parameters", new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        ChildrenMocks = new List<JsonPathFinder>()
+                                                        {
+                                                            new MockJsonPathFinder()
+                                                            {
+                                                                PathMock = "dummy",
+                                                                QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                                                {
+                                                                    { "name", new List<JsonPathFinder>()
+                                                                    {
+                                                                        new MockJsonPathFinder()
+                                                                        {
+                                                                            ValueMock = "nameFromSpec"
+                                                                        }
+                                                                    } },
+                                                                    { "x-ms-client-name", new List<JsonPathFinder>()
+                                                                    {
+                                                                        new MockJsonPathFinder()
+                                                                        {
+                                                                            ValueMock = "psParameterName"
+                                                                        }
+                                                                    } }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                } }
+                                            }
+                                        }.Container()
+                                    }
+                                }.Container()
+                            }
+                        }
+                    } }
+                }
+            };
 
             testModule.LoadMetadataFromSpecification(rootFinder);
 
@@ -337,36 +429,114 @@ public void FlattenedParameterRenamedUsingAutoRestExt()
             GeneratedModule expectedModule, testModule;
             GetLoadMetadataFromSpecificationTestData(out expectedModule, out testModule);
 
-            // Root document
-            MockJsonPathFinder rootFinder = new MockJsonPathFinder();
-            // Operation's "operationId" property
-            MockJsonPathFinder operationIdFinder = new MockJsonPathFinder();
-            operationIdFinder.ValueMock = "operationid";
-            // Operation node
-            MockJsonPathFinder operationFinder = new MockJsonPathFinder();
-            operationFinder.QueryMocks["operationId"] = new List<JsonPathFinder>() { operationIdFinder };
-            // Parameter's "schema.$ref" property
-            MockJsonPathFinder schemaRefFinder = new MockJsonPathFinder();
-            schemaRefFinder.ValueMock = "#/definitions/object";
-            // Parameter node
-            MockJsonPathFinder parameterFinder = new MockJsonPathFinder();
-            parameterFinder.QueryMocks["schema.$ref"] = new List<JsonPathFinder>() { schemaRefFinder };
-            parameterFinder.ParentMock = operationFinder.MakeDummyParent(2);
-            // Parameter's "x-ms-client-flatten" property
-            MockJsonPathFinder clientFlattenFinder = new MockJsonPathFinder();
-            clientFlattenFinder.ValueMock = true;
-            clientFlattenFinder.ParentMock = parameterFinder.MakeDummyParent();
-            // DefinitionProperty's "x-ms-client-name" property
-            MockJsonPathFinder clientNameFinder = new MockJsonPathFinder();
-            clientNameFinder.ValueMock = "psParameterName";
-            clientNameFinder.KeyMock = "nameFromSpec";
-            MockJsonPathFinder objectDefinitionFinder = new MockJsonPathFinder();
-            // The object definition will be queried for x-ms-client-name
-            objectDefinitionFinder.QueryMocks["..x-ms-client-name"] = new List<JsonPathFinder>() { clientNameFinder };
-            // The root will be queried for x-ms-client-flatten nodes
-            rootFinder.QueryMocks["paths..x-ms-client-flatten"] = new List<JsonPathFinder>() { clientFlattenFinder };
-            // The root will be queried for definitions
-            rootFinder.QueryMocks["$.definitions.object"] = new List<JsonPathFinder>() { objectDefinitionFinder };
+            MockJsonPathFinder rootFinder = new MockJsonPathFinder()
+            {
+                KeyMock = "root",
+                QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                {
+                    { "paths", new List<JsonPathFinder>()
+                    {
+                        new MockJsonPathFinder()
+                        {
+                            KeyMock = "paths",
+                            ChildrenMocks = new List<JsonPathFinder>()
+                            {
+                                new MockJsonPathFinder()
+                                {
+                                    KeyMock = "pathItem",
+                                    ChildrenMocks = new List<JsonPathFinder>()
+                                    {
+                                        new MockJsonPathFinder()
+                                        {
+                                            KeyMock = "getOperation",
+                                            QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                            {
+                                                { "operationId", new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        ValueMock = "operationid"
+                                                    }
+                                                } },
+                                                { "parameters", new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        ChildrenMocks = new List<JsonPathFinder>()
+                                                        {
+                                                            new MockJsonPathFinder()
+                                                            {
+                                                                PathMock = "dummy",
+                                                                QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                                                {
+                                                                    { "x-ms-client-flatten", new List<JsonPathFinder>()
+                                                                    {
+                                                                        new MockJsonPathFinder()
+                                                                        {
+                                                                            ValueMock = true
+                                                                        }
+                                                                    } },
+                                                                    { "..$ref", new List<JsonPathFinder>()
+                                                                    {
+                                                                        new MockJsonPathFinder()
+                                                                        {
+                                                                            ValueMock = "#/definitions/object"
+                                                                        }
+                                                                    } }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                } }
+                                            }
+                                        }.Container()
+                                    }
+                                }.Container()
+                            }
+                        }
+                    } },
+                    { "definitions", new List<JsonPathFinder>()
+                    {
+                        new MockJsonPathFinder()
+                        {
+                            ChildrenMocks = new List<JsonPathFinder>()
+                            {
+                                new MockJsonPathFinder()
+                                {
+                                    KeyMock = "object",
+                                    PathMock = "#/definitions/object",
+                                    QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                    {
+                                        { "properties", new List<JsonPathFinder>()
+                                        {
+                                            new MockJsonPathFinder()
+                                            {
+                                                ChildrenMocks = new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        KeyMock = "nameFromSpec",
+                                                        QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                                        {
+                                                            { "x-ms-client-name", new List<JsonPathFinder>()
+                                                            {
+                                                                new MockJsonPathFinder()
+                                                                {
+                                                                    ValueMock = "psParameterName"
+                                                                }
+                                                            } }
+                                                        }
+                                                    }.Container()
+                                                }
+                                            }
+                                        } }
+                                    }
+                                }.Container()
+                            }
+                        }
+                    } }
+                }
+            };
 
             testModule.LoadMetadataFromSpecification(rootFinder);
 
@@ -379,52 +549,155 @@ public void NestedFlattenedParameterRenamedUsingAutoRest()
             GeneratedModule expectedModule, testModule;
             GetLoadMetadataFromSpecificationTestData(out expectedModule, out testModule);
 
-            // Root document
-            MockJsonPathFinder rootFinder = new MockJsonPathFinder();
-            // Operation's "operationId" property
-            MockJsonPathFinder operationIdFinder = new MockJsonPathFinder();
-            operationIdFinder.ValueMock = "operationid";
-            // Operation node
-            MockJsonPathFinder operationFinder = new MockJsonPathFinder();
-            operationFinder.QueryMocks["operationId"] = new List<JsonPathFinder>() { operationIdFinder };
-            // Parameter's "schema.$ref" property
-            MockJsonPathFinder schemaRefFinder = new MockJsonPathFinder();
-            schemaRefFinder.ValueMock = "#/definitions/object";
-            // Parameter node
-            MockJsonPathFinder parameterFinder = new MockJsonPathFinder();
-            parameterFinder.QueryMocks["schema.$ref"] = new List<JsonPathFinder>() { schemaRefFinder };
-            parameterFinder.ParentMock = operationFinder.MakeDummyParent(2);
-            // Parameter's "x-ms-client-flatten" property
-            MockJsonPathFinder clientFlattenFinder = new MockJsonPathFinder();
-            clientFlattenFinder.ValueMock = true;
-            clientFlattenFinder.ParentMock = parameterFinder.MakeDummyParent();
-            // DefinitionProperty's "$ref" property
-            MockJsonPathFinder definitionPropertyRefFinder = new MockJsonPathFinder();
-            definitionPropertyRefFinder.ValueMock = "#/definitions/nestedObject";
-            // DefinitionProperty node
-            MockJsonPathFinder definitionPropertyFinder = new MockJsonPathFinder();
-            definitionPropertyFinder.QueryMocks["$ref"] = new List<JsonPathFinder>() { definitionPropertyRefFinder };
-            // DefinitionProperty's "x-ms-client-flatten" property
-            MockJsonPathFinder definitionClientFlattenFinder = new MockJsonPathFinder();
-            definitionClientFlattenFinder.ValueMock = true;
-            definitionClientFlattenFinder.ParentMock = definitionPropertyFinder.MakeDummyParent();
-            // object's node
-            MockJsonPathFinder objectDefinitionFinder = new MockJsonPathFinder();
-            // The object definition will be queried for x-ms-client-flatten
-            objectDefinitionFinder.QueryMocks["..x-ms-client-flatten"] = new List<JsonPathFinder>() { definitionClientFlattenFinder };
-            // NestedDefinitionProperty's "x-ms-client-name" property
-            MockJsonPathFinder clientNameFinder = new MockJsonPathFinder();
-            clientNameFinder.ValueMock = "psParameterName";
-            clientNameFinder.KeyMock = "nameFromSpec";
-            // nestedObject's node
-            MockJsonPathFinder nestedObjectDefinitionFinder = new MockJsonPathFinder();
-            // The object definition will be queried for x-ms-client-name
-            nestedObjectDefinitionFinder.QueryMocks["..x-ms-client-name"] = new List<JsonPathFinder>() { clientNameFinder };
-            // The root will be queried for x-ms-client-flatten nodes
-            rootFinder.QueryMocks["paths..x-ms-client-flatten"] = new List<JsonPathFinder>() { clientFlattenFinder };
-            // The root will be queried for definitions
-            rootFinder.QueryMocks["$.definitions.object"] = new List<JsonPathFinder>() { objectDefinitionFinder };
-            rootFinder.QueryMocks["$.definitions.nestedObject"] = new List<JsonPathFinder>() { nestedObjectDefinitionFinder };
+            MockJsonPathFinder rootFinder = new MockJsonPathFinder()
+            {
+                KeyMock = "root",
+                QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                {
+                    { "paths", new List<JsonPathFinder>()
+                    {
+                        new MockJsonPathFinder()
+                        {
+                            KeyMock = "paths",
+                            ChildrenMocks = new List<JsonPathFinder>()
+                            {
+                                new MockJsonPathFinder()
+                                {
+                                    KeyMock = "pathItem",
+                                    ChildrenMocks = new List<JsonPathFinder>()
+                                    {
+                                        new MockJsonPathFinder()
+                                        {
+                                            KeyMock = "getOperation",
+                                            QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                            {
+                                                { "operationId", new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        ValueMock = "operationid"
+                                                    }
+                                                } },
+                                                { "parameters", new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        ChildrenMocks = new List<JsonPathFinder>()
+                                                        {
+                                                            new MockJsonPathFinder()
+                                                            {
+                                                                PathMock = "dummy",
+                                                                QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                                                {
+                                                                    { "x-ms-client-flatten", new List<JsonPathFinder>()
+                                                                    {
+                                                                        new MockJsonPathFinder()
+                                                                        {
+                                                                            ValueMock = true
+                                                                        }
+                                                                    } },
+                                                                    { "..$ref", new List<JsonPathFinder>()
+                                                                    {
+                                                                        new MockJsonPathFinder()
+                                                                        {
+                                                                            ValueMock = "#/definitions/object"
+                                                                        }
+                                                                    } }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                } }
+                                            }
+                                        }.Container()
+                                    }
+                                }.Container()
+                            }
+                        }
+                    } },
+                    { "definitions", new List<JsonPathFinder>()
+                    {
+                        new MockJsonPathFinder()
+                        {
+                            ChildrenMocks = new List<JsonPathFinder>()
+                            {
+                                new MockJsonPathFinder()
+                                {
+                                    KeyMock = "object",
+                                    PathMock = "#/definitions/object",
+                                    QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                    {
+                                        { "properties", new List<JsonPathFinder>()
+                                        {
+                                            new MockJsonPathFinder()
+                                            {
+                                                ChildrenMocks = new List<JsonPathFinder>()
+                                                {
+                                                    new MockJsonPathFinder()
+                                                    {
+                                                        KeyMock = "properties",
+                                                        QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                                        {
+                                                            { "x-ms-client-flatten", new List<JsonPathFinder>()
+                                                            {
+                                                                new MockJsonPathFinder()
+                                                                {
+                                                                    ValueMock = true
+                                                                }
+                                                            } },
+                                                            { "$ref", new List<JsonPathFinder>()
+                                                            {
+                                                                new MockJsonPathFinder()
+                                                                {
+                                                                    ValueMock = "#/definitions/nestedObject"
+                                                                }
+                                                            } }
+                                                        }
+                                                    }.Container()
+                                                }
+                                            }
+                                        } }
+                                    }
+                                }.Container()
+                            }
+                        }
+                    } },
+                    { "$.definitions.nestedObject", new List<JsonPathFinder>()
+                    {
+                        new MockJsonPathFinder()
+                        {
+                            KeyMock = "nestedObject",
+                            PathMock = "#/definitions/nestedObject",
+                            QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                {
+                                    { "properties", new List<JsonPathFinder>()
+                                    {
+                                        new MockJsonPathFinder()
+                                        {
+                                            ChildrenMocks = new List<JsonPathFinder>()
+                                            {
+                                                new MockJsonPathFinder()
+                                                {
+                                                    KeyMock = "nameFromSpec",
+                                                    QueryMocks = new Dictionary<string, List<JsonPathFinder>>()
+                                                    {
+                                                        { "x-ms-client-name", new List<JsonPathFinder>()
+                                                        {
+                                                            new MockJsonPathFinder()
+                                                            {
+                                                                ValueMock = "psParameterName"
+                                                            }
+                                                        } }
+                                                    }
+                                                }.Container()
+                                            }
+                                        }
+                                    } }
+                                }
+                        } }
+                    }
+                }
+            };
 
             testModule.LoadMetadataFromSpecification(rootFinder);
 
@@ -460,8 +733,28 @@ private void GetLoadMetadataFromSpecificationTestData(out GeneratedModule expect
                              JsonName = "namefromspec"
                         }
                     }
+                },
+                ResponseType = new ResponseTypeData()
+                {
+                    ModuleData = new RuntimeTypeData()
+                    {
+                        Type = typeof(GeneratedModuleTestsSubObject)
+                    }
                 }
             };
+            expectedModule.Operations["operationid"].ResponseType.SpecificationData.Add(new RuntimeTypeData()
+            {
+                Properties = new Dictionary<string, ParameterData>()
+                        {
+                            { "pspropertyname", new ParameterData()
+                                {
+                                     Name = "pspropertyname",
+                                     JsonName = "propertynamefromspec"
+                                }
+                            }
+                        }
+            });
+            expectedModule.Operations["operationid"].ResponseType.Complete();
 
             testModule = new GeneratedModule(runspace);
             testModule.Operations["operationid"] = new OperationData("operationid", "command")
@@ -473,6 +766,13 @@ private void GetLoadMetadataFromSpecificationTestData(out GeneratedModule expect
                              Name = "psparametername"
                         }
                     }
+                },
+                ResponseType = new ResponseTypeData()
+                {
+                    ModuleData = new RuntimeTypeData()
+                    {
+                        Type = typeof(GeneratedModuleTestsSubObject)
+                    }
                 }
             };
         }
diff --git a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/JsonPathFinderTests.cs b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/JsonPathFinderTests.cs
index 9972644..53210ed 100644
--- a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/JsonPathFinderTests.cs
+++ b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/JsonPathFinderTests.cs
@@ -78,7 +78,7 @@ public void FindKeyOfObject()
             JsonPathFinder finder = new JsonPathFinder(json);
             JsonPathFinder childFinder = finder.Find("..sub").SingleOrDefault();
             Assert.NotNull(childFinder);
-            Assert.Equal("test", childFinder.Key);
+            Assert.Equal("sub", childFinder.Key);
         }
 
         [Fact]
@@ -88,7 +88,7 @@ public void FindKeyOfArray()
             JsonPathFinder finder = new JsonPathFinder(json);
             JsonPathFinder childFinder = finder.Find("..sub").SingleOrDefault();
             Assert.NotNull(childFinder);
-            Assert.Equal("test", childFinder.Key);
+            Assert.Equal("sub", childFinder.Key);
         }
 
         [Fact]
@@ -98,7 +98,7 @@ public void FindKeyOfValue()
             JsonPathFinder finder = new JsonPathFinder(json);
             JsonPathFinder childFinder = finder.Find("..sub").SingleOrDefault();
             Assert.NotNull(childFinder);
-            Assert.Equal("test", childFinder.Key);
+            Assert.Equal("sub", childFinder.Key);
         }
     }
 }
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/LiveTestRequestTests.cs b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/LiveTestRequestTests.cs
index 5f9b282..86eaf59 100644
--- a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/LiveTestRequestTests.cs
+++ b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/LiveTestRequestTests.cs
@@ -268,7 +268,7 @@ public void HttpResponseDataInError()
             Dictionary<string, object> headers = (Dictionary<string, object>)response.Error.Data.Headers;
             Assert.Equal(1, headers.Count);
             Assert.True(headers.ContainsKey("x-ms-header"));
-            Assert.Equal("value", headers["x-ms-header"]);
+            Assert.Equal(new string[] { "value" }, headers["x-ms-header"]);
 
             Assert.Equal((long)System.Net.HttpStatusCode.BadGateway, response.Error.Data.StatusCode);
         }
@@ -294,7 +294,7 @@ public void HttpResponseDataInResult()
             Dictionary<string, object> headers = (Dictionary<string, object>)response.Result.Headers;
             Assert.Equal(1, headers.Count);
             Assert.True(headers.ContainsKey("x-ms-header"));
-            Assert.Equal("value", headers["x-ms-header"]);
+            Assert.Equal(new string[] { "value" }, headers["x-ms-header"]);
 
             Assert.Equal((long)System.Net.HttpStatusCode.Accepted, response.Result.StatusCode);
         }
diff --git a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/Mocks/MockJsonPathFinder.cs b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/Mocks/MockJsonPathFinder.cs
index 37434ed..b6206aa 100644
--- a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/Mocks/MockJsonPathFinder.cs
+++ b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/Mocks/MockJsonPathFinder.cs
@@ -4,6 +4,7 @@
 namespace PSSwagger.LTF.Lib.UnitTests.Mocks
 {
     using Json;
+    using System;
     using System.Collections.Generic;
 
     /// <summary>
@@ -14,7 +15,9 @@ public class MockJsonPathFinder : JsonPathFinder
         public JsonPathFinder ParentMock { get; set; }
         public string KeyMock { get; set; }
         public object ValueMock { get; set; }
-        public Dictionary<string, List<JsonPathFinder>> QueryMocks { get; }
+        public string PathMock { get; set; }
+        public Dictionary<string, List<JsonPathFinder>> QueryMocks { get; set; }
+        public IList<JsonPathFinder> ChildrenMocks { get; set; }
         public override JsonPathFinder Parent
         {
             get
@@ -39,19 +42,39 @@ public override T GetValue<T>()
         public MockJsonPathFinder()
         {
             this.QueryMocks = new Dictionary<string, List<JsonPathFinder>>();
+            this.ChildrenMocks = new List<JsonPathFinder>();
         }
 
         public MockJsonPathFinder MakeDummyParent(int depth = 1)
         {
             MockJsonPathFinder currentLowestParent = new MockJsonPathFinder() { ParentMock = this };
+            this.ChildrenMocks.Add(currentLowestParent);
             while (--depth > 0)
             {
-                currentLowestParent = new MockJsonPathFinder() { ParentMock = currentLowestParent };
+                MockJsonPathFinder nextLowestParent = new MockJsonPathFinder() { ParentMock = currentLowestParent };
+                currentLowestParent.ChildrenMocks.Add(nextLowestParent);
+                currentLowestParent = nextLowestParent;
             }
 
             return currentLowestParent;
         }
 
+        public MockJsonPathFinder Container(int depth = 1)
+        {
+            MockJsonPathFinder currentHighestParent = new MockJsonPathFinder();
+            currentHighestParent.ChildrenMocks.Add(this);
+            this.ParentMock = currentHighestParent;
+            while (--depth > 0)
+            {
+                MockJsonPathFinder nextHighestParent = new MockJsonPathFinder();
+                nextHighestParent.ChildrenMocks.Add(this);
+                currentHighestParent.ParentMock = nextHighestParent;
+                currentHighestParent = nextHighestParent;
+            }
+
+            return currentHighestParent;
+        }
+
         public override IEnumerable<JsonPathFinder> Find(string jsonQuery)
         {
             if (this.QueryMocks.ContainsKey(jsonQuery))
@@ -59,7 +82,23 @@ public override IEnumerable<JsonPathFinder> Find(string jsonQuery)
                 return this.QueryMocks[jsonQuery];
             }
 
-            return null;
+            return new List<JsonPathFinder>();
+        }
+
+        public override IEnumerable<JsonPathFinder> Children()
+        {
+            foreach (JsonPathFinder child in this.ChildrenMocks)
+            {
+                yield return child;
+            }
+        }
+
+        public override string Path
+        {
+            get
+            {
+                return this.PathMock;
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/PowerShellRunspaceTests.cs b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/PowerShellRunspaceTests.cs
index 72afdb9..ae9f247 100644
--- a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/PowerShellRunspaceTests.cs
+++ b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/PowerShellRunspaceTests.cs
@@ -77,9 +77,12 @@ public void BasicHappyPathTest()
                             Type = new RuntimeTypeData(typeof(string))
                         }
                     }
+                },
+                ResponseType = new ResponseTypeData()
+                {
+                    ModuleData = new RuntimeTypeData(typeof(string))
                 }
             });
-            AssertModuleContainsOperation(result, new OperationData("Guitar_Get", "Get-Guitar"));
         }
 
         /// <summary>
@@ -203,20 +206,31 @@ private void AssertModuleContainsOperation(GeneratedModule result, OperationData
             PipelineVariable */
             Assert.True(result.Operations.ContainsKey(expectedOperation.OperationId.ToLowerInvariant()));
             Assert.Equal(expectedOperation.Parameters.Count, result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters.Count-11);
-
+            OperationData actualOperation = result.Operations[expectedOperation.OperationId.ToLowerInvariant()];
             foreach (string parmName in expectedOperation.Parameters.Keys)
             {
-                Assert.True(result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters.ContainsKey(parmName), parmName);
-                Assert.NotNull(result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters[parmName].Type);
-                Assert.Equal(expectedOperation.Parameters[parmName].Type.Type, result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters[parmName].Type.Type);
-                Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties.Count, result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters[parmName].Type.Properties.Count);
+                Assert.True(actualOperation.Parameters.ContainsKey(parmName), parmName);
+                Assert.NotNull(actualOperation.Parameters[parmName].Type);
+                Assert.Equal(expectedOperation.Parameters[parmName].Type.Type, actualOperation.Parameters[parmName].Type.Type);
+                Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties.Count, actualOperation.Parameters[parmName].Type.Properties.Count);
                 foreach (string propertyName in expectedOperation.Parameters[parmName].Type.Properties.Keys)
                 {
-                    Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].Type, result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters[parmName].Type.Properties[propertyName].Type);
-                    Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].Name, result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters[parmName].Type.Properties[propertyName].Name);
-                    Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].JsonName, result.Operations[expectedOperation.OperationId.ToLowerInvariant()].Parameters[parmName].Type.Properties[propertyName].JsonName);
+                    Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].Type, actualOperation.Parameters[parmName].Type.Properties[propertyName].Type);
+                    Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].Name, actualOperation.Parameters[parmName].Type.Properties[propertyName].Name);
+                    Assert.Equal(expectedOperation.Parameters[parmName].Type.Properties[propertyName].JsonName, actualOperation.Parameters[parmName].Type.Properties[propertyName].JsonName);
                 }
             }
+
+            if (expectedOperation.ResponseType != null)
+            {
+                Assert.NotNull(actualOperation.ResponseType);
+                Assert.NotNull(actualOperation.ResponseType.ModuleData);
+                Assert.Equal(expectedOperation.ResponseType.ModuleData.Type, actualOperation.ResponseType.ModuleData.Type);
+            }
+            else
+            {
+                Assert.Null(actualOperation.ResponseType);
+            }
         }
     }
 }
diff --git a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/data/Modules/BasicHappyPath/BasicHappyPath.psm1 b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/data/Modules/BasicHappyPath/BasicHappyPath.psm1
index a55f114..030fb6b 100644
--- a/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/data/Modules/BasicHappyPath/BasicHappyPath.psm1
+++ b/PSSwagger.LiveTestFramework/test/PSSwagger.LTF.Lib.UnitTests/data/Modules/BasicHappyPath/BasicHappyPath.psm1
@@ -17,6 +17,7 @@ function New-Guitar
 function Get-Guitar
 {
     [CmdletBinding(DefaultParameterSetName='Guitar_Get')]
+	[OutputType([System.String])]
     param(    
         [Parameter(Mandatory = $true, ParameterSetName = 'Guitar_GetById')]
         [System.String]
diff --git a/PSSwagger.LiveTestFramework/test/project-xunittest.proj b/PSSwagger.LiveTestFramework/test/project-xunittest.proj
index 31a5c82..68e765d 100644
--- a/PSSwagger.LiveTestFramework/test/project-xunittest.proj
+++ b/PSSwagger.LiveTestFramework/test/project-xunittest.proj
@@ -1,7 +1,7 @@
 <Project ToolsVersion="15.0">
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170618-03" />
-    <PackageReference Include="xunit" Version="2.3.0-beta3-build3705" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta3-build3705" />
+    <PackageReference Include="xunit" Version="2.3.0-beta4-build3742" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta4-build3742" />
   </ItemGroup>
 </Project>
\ No newline at end of file

From e7506588c9cf6f420d9d95f365252784b2b2d239 Mon Sep 17 00:00:00 2001
From: "Bryan Wang (PSHCT)" <brywang@microsoft.com>
Date: Wed, 6 Sep 2017 16:58:09 -0700
Subject: [PATCH 7/7] Argument validation

---
 .../Converters/LiveTestRequestConverter.cs    |  2 +-
 .../Logging/CompositeLogger.cs                | 20 +++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/LiveTestRequestConverter.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/LiveTestRequestConverter.cs
index 6c87574..c125229 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/LiveTestRequestConverter.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Converters/LiveTestRequestConverter.cs
@@ -191,7 +191,7 @@ private bool ConvertObject(object val, Type expectedType, JsonSerializer seriali
 
         private void Log(string msg, params object[] args)
         {
-            if (this.module.Logger != null)
+            if (this.module.Logger != null && !String.IsNullOrEmpty(msg))
             {
                 this.module.Logger.Log(msg, args);
             }
diff --git a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs
index 95519cb..37f2bda 100644
--- a/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs
+++ b/PSSwagger.LiveTestFramework/src/PSSwagger.LTF.Lib/Logging/CompositeLogger.cs
@@ -26,6 +26,11 @@ public CompositeLogger() : base(null, null)
 
         public CompositeLogger AddLogger(Logger logger)
         {
+            if (logger == null)
+            {
+                throw new ArgumentNullException("logger");
+            }
+
             this.InternalLoggers.Add(logger);
             return this;
         }
@@ -36,6 +41,11 @@ public CompositeLogger AddLogger(Logger logger)
         /// <param name="message">Message to log.</param>
         public override void Log(string message, params object[] args)
         {
+            if (String.IsNullOrEmpty(message))
+            {
+                return;
+            }
+
             foreach (Logger logger in this.InternalLoggers)
             {
                 logger.Log(message, args);
@@ -49,6 +59,11 @@ public override void Log(string message, params object[] args)
         /// <param name="objs">Objects to serialize.</param>
         public override async Task LogAsync(string message, params object[] objs)
         {
+            if (String.IsNullOrEmpty(message))
+            {
+                return;
+            }
+
             foreach (Logger logger in this.InternalLoggers)
             {
                 logger.LogAsync(message);
@@ -61,6 +76,11 @@ public override async Task LogAsync(string message, params object[] objs)
         /// <param name="message"></param>
         public void LogError(string message)
         {
+            if (String.IsNullOrEmpty(message))
+            {
+                return;
+            }
+
             foreach (Logger logger in this.InternalLoggers)
             {
                 logger.LogError(message);