Protocol v2 changes

src/Microsoft.TestPlatform.CommunicationUtilities/Interfaces/ICommunicationManager.cs

@@ -105,6 +105,14 @@ public interface ICommunicationManager
  /// <param name="payload">payload to be sent</param>
  void SendMessage(string messageType, object payload);
 
+ /// <summary>
+ /// Writes message to the binary writer with payload
+ /// </summary>
+ /// <param name="messageType">Type of Message to be sent, for instance TestSessionStart</param>
+ /// <param name="payload">payload to be sent</param>
+ /// <param name="version">version to be sent</param>
+ void SendMessage(string messageType, object payload, int version);
+
  /// <summary>
  /// Send serialized raw message
  /// </summary>

src/Microsoft.TestPlatform.CommunicationUtilities/Interfaces/IDataSerializer.cs

@@ -37,5 +37,14 @@ public interface IDataSerializer
  /// <param name="payload">Payload of the message</param>
  /// <returns>Raw Serialized message</returns>
  string SerializePayload(string messageType, object payload);
+
+ /// <summary>
+ /// Serializes and creates a raw message given a message type and the object payload
+ /// </summary>
+ /// <param name="messageType">Message Type</param>
+ /// <param name="payload">Payload of the message</param>
+ /// <param name="version">version to be sent</param>
+ /// <returns>Raw Serialized message</returns>
+ string SerializePayload(string messageType, object payload, int version);
  }
 }

src/Microsoft.TestPlatform.CommunicationUtilities/Interfaces/ITestRequestSender.cs

@@ -20,6 +20,12 @@ public interface ITestRequestSender : IDisposable
  /// <returns>Port Number of the communication channel</returns>
  int InitializeCommunication();
 
+ /// <summary>
+ /// Used for protocol version check with TestHost
+ /// </summary>
+ /// <returns>true if the version check is successful</returns>
+ bool CheckVersionWithTestHost();
+
  /// <summary>
  /// Waits for Request Handler to be connected
  /// </summary>

src/Microsoft.TestPlatform.CommunicationUtilities/JsonDataSerializer.cs

@@ -6,7 +6,6 @@ namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities
  using System.IO;
 
  using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Interfaces;
- using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.ObjectModel;
  using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Serialization;
 
  using Newtonsoft.Json;
@@ -20,26 +19,33 @@ public class JsonDataSerializer : IDataSerializer
  {
  private static JsonDataSerializer instance;
 
- private static JsonSerializer serializer;
+ private static JsonSerializer payloadSerializer;
+ private static JsonSerializer payloadSerializer2;
 
  /// <summary>
  /// Prevents a default instance of the <see cref="JsonDataSerializer"/> class from being created.
  /// </summary>
  private JsonDataSerializer()
  {
- serializer = JsonSerializer.Create(
- new JsonSerializerSettings
- {
- ContractResolver = new TestPlatformContractResolver(),
- DateFormatHandling = DateFormatHandling.IsoDateFormat,
- DateParseHandling = DateParseHandling.DateTimeOffset,
- DateTimeZoneHandling = DateTimeZoneHandling.Utc,
- TypeNameHandling = TypeNameHandling.None
- });
+ var jsonSettings = new JsonSerializerSettings
+ {
+ DateFormatHandling = DateFormatHandling.IsoDateFormat,
+ DateParseHandling = DateParseHandling.DateTimeOffset,
+ DateTimeZoneHandling = DateTimeZoneHandling.Utc,
+ TypeNameHandling = TypeNameHandling.None
+ };
+
+ payloadSerializer = JsonSerializer.Create(jsonSettings);
+ payloadSerializer2 = JsonSerializer.Create(jsonSettings);
+
+ payloadSerializer.ContractResolver = new TestPlatformContractResolver1();
+ payloadSerializer2.ContractResolver = new DefaultTestPlatformContractResolver();
+
 #if DEBUG
  // MemoryTraceWriter can help diagnose serialization issues. Enable it for
  // debug builds only.
- serializer.TraceWriter = new MemoryTraceWriter();
+ payloadSerializer.TraceWriter = new MemoryTraceWriter();
+ payloadSerializer2.TraceWriter = new MemoryTraceWriter();
 #endif
  }
 
@@ -61,7 +67,9 @@ public static JsonDataSerializer Instance
  /// <returns>A <see cref="Message"/> instance.</returns>
  public Message DeserializeMessage(string rawMessage)
  {
- return JsonConvert.DeserializeObject<Message>(rawMessage);
+ // Convert to VersionedMessage
+ // Message can be deserialized to VersionedMessage where version will be 0
+ return JsonConvert.DeserializeObject<VersionedMessage>(rawMessage);
  }
 
  /// <summary>
@@ -74,28 +82,24 @@ public T DeserializePayload<T>(Message message)
  {
  T retValue = default(T);
 
- // TODO: Currently we use json serializer auto only for non-testmessage types
- // CHECK: Can't we just use auto for everything
- if (MessageType.TestMessage.Equals(message.MessageType))
- {
- retValue = message.Payload.ToObject<T>();
- }
- else
- {
- retValue = message.Payload.ToObject<T>(serializer);
- }
+ var versionedMessage = message as VersionedMessage;
+ var serializer = versionedMessage?.Version == 2 ? payloadSerializer2 : payloadSerializer;
 
+ retValue = message.Payload.ToObject<T>(serializer);
  return retValue;
  }
 
  /// <summary>
  /// Deserialize raw JSON to an object using the default serializer.
  /// </summary>
  /// <param name="json">JSON string.</param>
+ /// <param name="version">Version of serializer to be used.</param>
  /// <typeparam name="T">Target type to deserialize.</typeparam>
  /// <returns>An instance of <see cref="T"/>.</returns>
- public T Deserialize<T>(string json)
+ public T Deserialize<T>(string json, int version = 1)
  {
+ var serializer = version == 2 ? payloadSerializer2 : payloadSerializer;
+
  using (var stringReader = new StringReader(json))
  using (var jsonReader = new JsonTextReader(stringReader))
  {
@@ -121,30 +125,41 @@ public string SerializeMessage(string messageType)
  /// <returns>Serialized message.</returns>
  public string SerializePayload(string messageType, object payload)
  {
- JToken serializedPayload = null;
-
- // TODO: Currently we use json serializer auto only for non-testmessage types
- // CHECK: Can't we just use auto for everything
- if (MessageType.TestMessage.Equals(messageType))
- {
- serializedPayload = JToken.FromObject(payload);
- }
- else
- {
- serializedPayload = JToken.FromObject(payload, serializer);
- }
+ var serializedPayload = JToken.FromObject(payload, payloadSerializer);
 
  return JsonConvert.SerializeObject(new Message { MessageType = messageType, Payload = serializedPayload });
  }
 
+ /// <summary>
+ /// Serialize a message with payload.
+ /// </summary>
+ /// <param name="messageType">Type of the message.</param>
+ /// <param name="payload">Payload for the message.</param>
+ /// <param name="version">Version for the message.</param>
+ /// <returns>Serialized message.</returns>
+ public string SerializePayload(string messageType, object payload, int version)
+ {
+ var serializer = version == 2 ? payloadSerializer2 : payloadSerializer;
+ var serializedPayload = JToken.FromObject(payload, serializer);
+
+ var message = version == 1 ?
+ new Message { MessageType = messageType, Payload = serializedPayload } :
+ new VersionedMessage { MessageType = messageType, Version = version, Payload = serializedPayload };
+
+ return JsonConvert.SerializeObject(message);
+ }
+
  /// <summary>
  /// Serialize an object to JSON using default serialization settings.
  /// </summary>
  /// <typeparam name="T">Type of object to serialize.</typeparam>
  /// <param name="data">Instance of the object to serialize.</param>
+ /// <param name="version">Version to be stamped.</param>
  /// <returns>JSON string.</returns>
- public string Serialize<T>(T data)
+ public string Serialize<T>(T data, int version = 1)
  {
+ var serializer = version == 2 ? payloadSerializer2 : payloadSerializer;
+
  using (var stringWriter = new StringWriter())
  using (var jsonWriter = new JsonTextWriter(stringWriter))
  {

src/Microsoft.TestPlatform.CommunicationUtilities/Messages/Message.cs

@@ -6,6 +6,9 @@ namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities
  using Newtonsoft.Json;
  using Newtonsoft.Json.Linq;
 
+ /// <summary>
+ /// Construct used for communication
+ /// </summary>
  public class Message
  {
  /// <summary>

src/Microsoft.TestPlatform.CommunicationUtilities/Messages/MessageType.cs

@@ -38,6 +38,11 @@ public static class MessageType
  /// </summary>
  public const string VersionCheck = "ProtocolVersion";
 
+ /// <summary>
+ /// Protocol Error
+ /// </summary>
+ public const string ProtocolError = "ProtocolError";
+
  /// <summary>
  /// The session start.
  /// </summary>

src/Microsoft.TestPlatform.CommunicationUtilities/Messages/VersionedMessage.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities
+{
+ /// <summary>
+ /// New construct with version used for communication
+ /// </summary>
+ public class VersionedMessage : Message
+ {
+ /// <summary>
+ /// Gets or sets the version of the message
+ /// </summary>
+ public int Version { get; set; }
+ }
+}

src/Microsoft.TestPlatform.CommunicationUtilities/Serialization/TestPlatformContractResolver.cs → src/Microsoft.TestPlatform.CommunicationUtilities/Serialization/DefaultTestPlatformContractResolver.cs

@@ -14,7 +14,7 @@ namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Serializati
  /// <summary>
  /// JSON contract resolver for mapping test platform types.
  /// </summary>
- public class TestPlatformContractResolver : DefaultContractResolver
+ public class DefaultTestPlatformContractResolver : DefaultContractResolver
  {
  /// <inheritdoc/>
  protected override JsonContract CreateContract(Type objectType)

src/Microsoft.TestPlatform.CommunicationUtilities/Serialization/TestCaseConverter.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Serialization
+{
+ using System;
+ using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+ using Newtonsoft.Json;
+
+ /// <inheritdoc/>
+ public class TestCaseConverter : JsonConverter
+ {
+ /// <inheritdoc/>
+ public override bool CanRead => false;
+
+ /// <inheritdoc/>
+ public override bool CanConvert(Type objectType)
+ {
+ return typeof(TestCase) == objectType;
+ }
+
+ /// <inheritdoc/>
+ public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /// <inheritdoc/>
+ public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+ {
+ // P2 to P1
+ var testCase = value as TestCase;
+ var properties = testCase.GetProperties();
+
+ writer.WriteStartObject();
+ writer.WritePropertyName("Properties");
+ writer.WriteStartArray();
+ foreach (var property in properties)
+ {
+ serializer.Serialize(writer, property);
+ }
+
+ writer.WriteEndArray();
+ writer.WriteEndObject();
+ }
+ }
+}

src/Microsoft.TestPlatform.CommunicationUtilities/Serialization/TestPlatformContractResolver1.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Serialization
+{
+ using System;
+ using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+ using Newtonsoft.Json.Serialization;
+
+ /// <summary>
+ /// JSON contract resolver for mapping test platform types for v1 serialization.
+ /// </summary>
+ public class TestPlatformContractResolver1 : DefaultTestPlatformContractResolver
+ {
+ /// <inheritdoc/>
+ protected override JsonContract CreateContract(Type objectType)
+ {
+ var contract = base.CreateContract(objectType);
+ if (typeof(TestCase) == objectType)
+ {
+ contract.Converter = new TestCaseConverter();
+ }
+
+ if (typeof(TestResult) == objectType)
+ {
+ contract.Converter = new TestResultConverter();
+ }
+
+ return contract;
+ }
+ }
+}

src/Microsoft.TestPlatform.CommunicationUtilities/Serialization/TestResultConverter.cs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Serialization
+{
+ using System;
+ using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+ using Newtonsoft.Json;
+
+ /// <inheritdoc/>
+ public class TestResultConverter : JsonConverter
+ {
+ /// <inheritdoc/>
+ public override bool CanRead => false;
+
+ /// <inheritdoc/>
+ public override bool CanConvert(Type objectType)
+ {
+ return typeof(TestResult) == objectType;
+ }
+
+ /// <inheritdoc/>
+ public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /// <inheritdoc/>
+ public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+ {
+ // P2 to P1
+ var testResult = value as TestResult;
+ var properties = testResult.GetProperties();
+
+ writer.WriteStartObject();
+ writer.WritePropertyName("TestCase");
+ serializer.Serialize(writer, testResult.TestCase);
+ writer.WritePropertyName("Attachments");
+ serializer.Serialize(writer, testResult.Attachments);
+ writer.WritePropertyName("Messages");
+ serializer.Serialize(writer, testResult.Messages);
+
+ writer.WritePropertyName("Properties");
+ writer.WriteStartArray();
+ foreach (var property in properties)
+ {
+ serializer.Serialize(writer, property);
+ }
+
+ writer.WriteEndArray();
+ writer.WriteEndObject();
+ }
+ }
+}