Progress feature, compiling + unit tests

src/Microsoft.TestPlatform.Client/MultiTestRunFinalization/MultiTestRunFinalizationEventsHandler.cs

@@ -27,14 +27,7 @@ public MultiTestRunFinalizationEventsHandler(ICommunicationManager communication
         }
 
         /// <inheritdoc/>
-        public void HandleLogMessage(TestMessageLevel level, string message)
-        {
-            var testMessagePayload = new TestMessagePayload { MessageLevel = level, Message = message };
-            this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);
-        }
-
-        /// <inheritdoc/>
-        public void HandleMultiTestRunFinalizationComplete(ICollection<AttachmentSet> attachments)
+        public void HandleMultiTestRunFinalizationComplete(MultiTestRunFinalizationCompleteEventArgs finalizationCompleteEventArgs, IEnumerable<AttachmentSet> lastChunk)
         {
             if (EqtTrace.IsInfoEnabled)
             {
@@ -43,13 +36,37 @@ public void HandleMultiTestRunFinalizationComplete(ICollection<AttachmentSet> at
 
             var payload = new MultiTestRunFinalizationCompletePayload()
             {
-                Attachments = attachments
+                FinalizationCompleteEventArgs = finalizationCompleteEventArgs,
+                Attachments = lastChunk
             };
 
-            // Send run complete to translation layer
             this.communicationManager.SendMessage(MessageType.MultiTestRunFinalizationComplete, payload);
         }
 
+        /// <inheritdoc/>
+        public void HandleMultiTestRunFinalizationProgress(MultiTestRunFinalizationProgressEventArgs finalizationProgressEventArgs)
+        {
+            var payload = new MultiTestRunFinalizationProgressPayload()
+            {
+                FinalizationProgressEventArgs = finalizationProgressEventArgs,
+            };
+
+            this.communicationManager.SendMessage(MessageType.MultiTestRunFinalizationProgress, payload);
+        }
+
+        /// <inheritdoc/>
+        public void HandleFinalisedAttachments(IEnumerable<AttachmentSet> attachments)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public void HandleLogMessage(TestMessageLevel level, string message)
+        {
+            var testMessagePayload = new TestMessagePayload { MessageLevel = level, Message = message };
+            this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);
+        }
+
         /// <inheritdoc/>
         public void HandleRawMessage(string rawMessage)
         {

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

@@ -133,6 +133,11 @@ public static class MessageType
         /// </summary>
         public const string MultiTestRunFinalizationComplete = "MultiTestRunFinalization.Complete";
 
+        /// <summary>
+        /// Multi test run finalization progress
+        /// </summary>
+        public const string MultiTestRunFinalizationProgress = "MultiTestRunFinalization.Progress";
+
         /// <summary>
         /// Cancel multi test run finalization
         /// </summary>

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

@@ -6,15 +6,21 @@ namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.ObjectModel
     using System.Collections.Generic;
 
     using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client;
 
     /// <summary>
     /// Multi test run finalization complete payload.
     /// </summary>
     public class MultiTestRunFinalizationCompletePayload
     {
+        /// <summary>
+        /// Gets or sets the multi test run finalization complete args.
+        /// </summary>
+        public MultiTestRunFinalizationCompleteEventArgs FinalizationCompleteEventArgs { get; set; }
+
         /// <summary>
         /// Gets or sets the attachments.
         /// </summary>
-        public ICollection<AttachmentSet> Attachments { get; set; }
+        public IEnumerable<AttachmentSet> Attachments { get; set; }
     }
 }

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

@@ -0,0 +1,18 @@
+// 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.ObjectModel
+{
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client;
+
+    /// <summary>
+    /// Multi test run finalization complete payload.
+    /// </summary>
+    public class MultiTestRunFinalizationProgressPayload
+    {
+        /// <summary>
+        /// Gets or sets the multi test run finalization complete args.
+        /// </summary>
+        public MultiTestRunFinalizationProgressEventArgs FinalizationProgressEventArgs { get; set; }
+    }
+}

src/Microsoft.TestPlatform.CrossPlatEngine/MultiTestRunFinalization/MultiTestRunFinalizationManager.cs

@@ -65,19 +65,19 @@ private async Task<Collection<AttachmentSet>> InternalFinalizeMultiTestRunAsync(
                 {
                     Task<Collection<AttachmentSet>> task = Task.Run(() =>
                     {
-                        return ProcessAttachments(new Collection<AttachmentSet>(attachments.ToList()), new ProgressReporter(eventHandler, dataCollectorAttachmentsHandlers.Length), cancellationToken);
+                        return ProcessAttachments(new Collection<AttachmentSet>(attachments.ToList()), eventHandler, cancellationToken);
                     });
 
                     var completedTask = await Task.WhenAny(task, taskCompletionSource.Task).ConfigureAwait(false);
 
                     if (completedTask == task)
                     {
-                        return FinalizeOperation(requestData, await task, eventHandler, FinalizationCompleted);
+                        return FinalizeOperation(requestData, new MultiTestRunFinalizationCompleteEventArgs(false, false, null), await task, eventHandler);
                     }
                     else
                     {
                         eventHandler?.HandleLogMessage(ObjectModel.Logging.TestMessageLevel.Informational, "Finalization was cancelled.");
-                        return FinalizeOperation(requestData, attachments, eventHandler, FinalizationCanceled);
+                        return FinalizeOperation(requestData, new MultiTestRunFinalizationCompleteEventArgs(true, false, null), attachments, eventHandler);
                     }
                 }
             }
@@ -87,14 +87,14 @@ private async Task<Collection<AttachmentSet>> InternalFinalizeMultiTestRunAsync(
                 {
                     EqtTrace.Warning("MultiTestRunFinalizationManager: operation was cancelled.");
                 }
-                return FinalizeOperation(requestData, attachments, eventHandler, FinalizationCanceled);
+                return FinalizeOperation(requestData, new MultiTestRunFinalizationCompleteEventArgs(true, false, null), attachments, eventHandler);
             }
             catch (Exception e)
             {
                 EqtTrace.Error("MultiTestRunFinalizationManager: Exception in FinalizeMultiTestRunAsync: " + e);
 
                 eventHandler?.HandleLogMessage(ObjectModel.Logging.TestMessageLevel.Error, e.Message);
-                return FinalizeOperation(requestData, attachments, eventHandler, FinalizationFailed);
+                return FinalizeOperation(requestData, new MultiTestRunFinalizationCompleteEventArgs(false, true, e), attachments, eventHandler);
             }
             finally
             {
@@ -103,12 +103,15 @@ private async Task<Collection<AttachmentSet>> InternalFinalizeMultiTestRunAsync(
             }
         }
 
-        private Collection<AttachmentSet> ProcessAttachments(Collection<AttachmentSet> attachments, ProgressReporter progressReporter, CancellationToken cancellationToken)
+        private Collection<AttachmentSet> ProcessAttachments(Collection<AttachmentSet> attachments, IMultiTestRunFinalizationEventsHandler eventsHandler, CancellationToken cancellationToken)
         {
-            if (attachments == null || !attachments.Any()) return attachments;           
+            if (attachments == null || !attachments.Any()) return attachments;
 
-            foreach (var dataCollectorAttachmentsHandler in dataCollectorAttachmentsHandlers)
+            for (int i = 0; i < dataCollectorAttachmentsHandlers.Length; i++)
             {
+                IDataCollectorAttachments dataCollectorAttachmentsHandler = dataCollectorAttachmentsHandlers[i];
+                string attachmentsHandlerName = dataCollectorAttachmentsHandler.GetType().FullName;
+
                 Uri attachementUri = dataCollectorAttachmentsHandler.GetExtensionUri();
                 if (attachementUri != null)
                 {
@@ -120,6 +123,9 @@ private Collection<AttachmentSet> ProcessAttachments(Collection<AttachmentSet> a
                             attachments.Remove(attachment);
                         }
 
+                        IProgress<int> progressReporter = new Progress<int>((int progress) => 
+                            eventsHandler?.HandleMultiTestRunFinalizationProgress(
+                                new MultiTestRunFinalizationProgressEventArgs(i + 1, attachmentsHandlerName, progress, dataCollectorAttachmentsHandlers.Length)));
                         ICollection<AttachmentSet> processedAttachments = dataCollectorAttachmentsHandler.HandleDataCollectionAttachmentSets(new Collection<AttachmentSet>(attachmentsToBeProcessed), progressReporter, cancellationToken);
                         foreach (var attachment in processedAttachments)
                         {
@@ -132,38 +138,16 @@ private Collection<AttachmentSet> ProcessAttachments(Collection<AttachmentSet> a
             return attachments;
         }
 
-        private Collection<AttachmentSet> FinalizeOperation(IRequestData requestData, Collection<AttachmentSet> attachments, IMultiTestRunFinalizationEventsHandler eventHandler, string finalizationState)
-        {
-            eventHandler?.HandleMultiTestRunFinalizationComplete(attachments);
+        private Collection<AttachmentSet> FinalizeOperation(IRequestData requestData, MultiTestRunFinalizationCompleteEventArgs completeArgs, Collection<AttachmentSet> attachments, IMultiTestRunFinalizationEventsHandler eventHandler)
+        {            
             testPlatformEventSource.MultiTestRunFinalizationStop(attachments.Count);
             requestData.MetricsCollection.Add(TelemetryDataConstants.NumberOfAttachmentsAfterFinalization, attachments.Count);
-            requestData.MetricsCollection.Add(TelemetryDataConstants.FinalizationState, finalizationState);
-
-            return attachments;
-        }
+            requestData.MetricsCollection.Add(TelemetryDataConstants.FinalizationState, completeArgs.IsAborted ? FinalizationFailed : completeArgs.IsCanceled ? FinalizationCanceled : FinalizationCompleted);
 
-        private class ProgressReporter : IProgress<int>
-        {
-            private readonly IMultiTestRunFinalizationEventsHandler eventsHandler;
-            private readonly int totalNumberOfHandlers;
-            private int currentHandlerIndex;
+            completeArgs.Metrics = requestData.MetricsCollection.Metrics;
+            eventHandler?.HandleMultiTestRunFinalizationComplete(completeArgs, attachments);
 
-            public ProgressReporter(IMultiTestRunFinalizationEventsHandler eventsHandler, int totalNumberOfHandlers)
-            {
-                this.eventsHandler = eventsHandler;
-                this.currentHandlerIndex = 0;
-                this.totalNumberOfHandlers = totalNumberOfHandlers;
-            }
-
-            public void IncremenetHandlerIndex()
-            {
-                currentHandlerIndex++;
-            }
-
-            public void Report(int value)
-            {
-                //eventsHandler.report( current, total, value)
-            }
+            return attachments;
         }
     }
 }

src/Microsoft.TestPlatform.ObjectModel/Client/Events/MultiTestRunFinalizationCompleteEventArgs.cs

@@ -0,0 +1,50 @@
+// 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.ObjectModel.Client
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Runtime.Serialization;
+
+    [DataContract]
+    public class MultiTestRunFinalizationCompleteEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        /// <param name="isCanceled">Specifies whether the finalization is canceled.</param>
+        /// <param name="isAborted">Specifies whether the finalization is aborted.</param>
+        /// <param name="error">Specifies the error encountered during the execution of the finalization.</param>
+        public MultiTestRunFinalizationCompleteEventArgs(bool isCanceled, bool isAborted, Exception error)
+        {
+            this.IsCanceled = isCanceled;
+            this.IsAborted = isAborted;
+            this.Error = error;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the finalization is aborted or not.
+        /// </summary>
+        [DataMember]
+        public bool IsAborted { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the finalization is canceled or not.
+        /// </summary>
+        [DataMember]
+        public bool IsCanceled { get; private set; }
+
+        /// <summary>
+        /// Gets the error encountered during the finalization of the test runs. Null if there is no error.
+        /// </summary>
+        [DataMember]
+        public Exception Error { get; private set; }
+
+        /// <summary>
+        /// Get or Sets the Metrics
+        /// </summary>
+        [DataMember]
+        public IDictionary<string, object> Metrics { get; set; }
+    }
+}

src/Microsoft.TestPlatform.ObjectModel/Client/Events/MultiTestRunFinalizationProgressEventArgs.cs

@@ -0,0 +1,51 @@
+// 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.ObjectModel.Client
+{
+    using System;
+    using System.Runtime.Serialization;
+
+    [DataContract]
+    public class MultiTestRunFinalizationProgressEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        /// <param name="currentHandlerIndex">Specifies current handler index.</param>
+        /// <param name="currentHandlerName">Specifies current handler name.</param>
+        /// <param name="currentHandlerProgress">Specifies current handler progress.</param>
+        /// <param name="handlersCount">Specifies the overall number of handlers.</param>
+        public MultiTestRunFinalizationProgressEventArgs(long currentHandlerIndex, string currentHandlerName, long currentHandlerProgress, long handlersCount)
+        {
+            CurrentHandlerIndex = currentHandlerIndex;
+            CurrentHandlerName = currentHandlerName;
+            CurrentHandlerProgress = currentHandlerProgress;
+            HandlersCount = handlersCount;
+        }
+
+        /// <summary>
+        /// Gets a current handler index.
+        /// </summary>
+        [DataMember]
+        public long CurrentHandlerIndex { get; private set; }
+
+        /// <summary>
+        /// Gets a current handler name.
+        /// </summary>
+        [DataMember]
+        public string CurrentHandlerName { get; private set; }
+
+        /// <summary>
+        /// Gets a current handler progress.
+        /// </summary>
+        [DataMember]
+        public long CurrentHandlerProgress { get; private set; }
+
+        /// <summary>
+        /// Gets the overall number of handlers.
+        /// </summary>
+        [DataMember]
+        public long HandlersCount { get; private set; }
+    }
+}

src/Microsoft.TestPlatform.ObjectModel/Client/Interfaces/IMultiTestRunFinalizationEventsHandler.cs

@@ -13,7 +13,20 @@ public interface IMultiTestRunFinalizationEventsHandler : ITestMessageEventHandl
         /// <summary>
         /// Dispatch MultiTestRunFinalizationComplete event to listeners.
         /// </summary>
-        /// <param name="attachments">Attachments reprocessed.</param>
-        void HandleMultiTestRunFinalizationComplete(ICollection<AttachmentSet> attachments);
+        /// <param name="finalizationCompleteEventArgs">Finalization Complete event args.</param>
+        /// <param name="attachments">Last set of processed attachment sets.</param>
+        void HandleMultiTestRunFinalizationComplete(MultiTestRunFinalizationCompleteEventArgs finalizationCompleteEventArgs, IEnumerable<AttachmentSet> lastChunk);
+
+        /// <summary>
+        /// Dispatch FinalisedAttachments event to listeners.
+        /// </summary>
+        /// <param name="attachments">Finalised attachment sets.</param>
+        void HandleFinalisedAttachments(IEnumerable<AttachmentSet> attachments);
+
+        /// <summary>
+        /// Dispatch MultiTestRunFinalizationProgress event to listeners.
+        /// </summary>
+        /// <param name="finalizationProgressEventArgs">Finalization Progress event args.</param>
+        void HandleMultiTestRunFinalizationProgress(MultiTestRunFinalizationProgressEventArgs finalizationProgressEventArgs);
     }
 }

src/Microsoft.TestPlatform.VsTestConsole.TranslationLayer/VsTestConsoleRequestSender.cs

@@ -762,9 +762,14 @@ private async Task SendMessageAndListenAndReportFinalizationResultAsync(IEnumera
 
                             var multiTestRunFinalizationCompletePayload = this.dataSerializer.DeserializePayload<MultiTestRunFinalizationCompletePayload>(message);
 
-                            eventHandler.HandleMultiTestRunFinalizationComplete(multiTestRunFinalizationCompletePayload.Attachments);
+                            eventHandler.HandleMultiTestRunFinalizationComplete(multiTestRunFinalizationCompletePayload.FinalizationCompleteEventArgs, multiTestRunFinalizationCompletePayload.Attachments);
                             isMultiTestRunFinalizationComplete = true;
                         }
+                        else if (string.Equals(MessageType.MultiTestRunFinalizationProgress, message.MessageType))
+                        {
+                            var multiTestRunFinalizationProgressPayload = this.dataSerializer.DeserializePayload<MultiTestRunFinalizationProgressPayload>(message);
+                            eventHandler.HandleMultiTestRunFinalizationProgress(multiTestRunFinalizationProgressPayload.FinalizationProgressEventArgs);
+                        }
                         else if (string.Equals(MessageType.TestMessage, message.MessageType))
                         {
                             var testMessagePayload = this.dataSerializer.DeserializePayload<TestMessagePayload>(message);
@@ -777,7 +782,7 @@ private async Task SendMessageAndListenAndReportFinalizationResultAsync(IEnumera
             {
                 EqtTrace.Error("Aborting Test Session End Operation: {0}", exception);
                 eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedMultiTestRunFinalization);               
-                eventHandler.HandleMultiTestRunFinalizationComplete(null);
+                eventHandler.HandleMultiTestRunFinalizationComplete(new MultiTestRunFinalizationCompleteEventArgs(false, true, exception), null);
 
                 // Earlier we were closing the connection with vstest.console in case of exceptions
                 // Removing that code because vstest.console might be in a healthy state and letting the client