Spelling and test fixes

Author: JohnMcPMS

src/AppInstallerCLICore/ContextOrchestrator.cpp

@@ -214,12 +214,12 @@ namespace AppInstaller::CLI::Execution
         }
     }
 
-    bool ContextOrchestrator::WaitForRunningItems(DWORD timeoutMiliseconds)
+    bool ContextOrchestrator::WaitForRunningItems(DWORD timeoutMilliseconds)
     {
         std::lock_guard<std::mutex> lock{ m_queueLock };
         for (const auto& queue : m_commandQueues)
         {
-            if (!queue.second->WaitForEmptyQueue(timeoutMiliseconds))
+            if (!queue.second->WaitForEmptyQueue(timeoutMilliseconds))
             {
                 return false;
             }
@@ -228,6 +228,25 @@ namespace AppInstaller::CLI::Execution
         return true;
     }
 
+    std::string ContextOrchestrator::GetStatusString()
+    {
+        std::ostringstream stream;
+
+        std::lock_guard<std::mutex> lock{ m_queueLock };
+
+        if (!m_enabled)
+        {
+            stream << "Disabled due to " << ToIntegral(m_disabledReason) << std::endl;
+        }
+
+        for (const auto& queue : m_commandQueues)
+        {
+            stream << queue.second->GetStatusString();
+        }
+
+        return stream.str();
+    }
+
     _Requires_lock_held_(m_itemLock)
     std::deque<std::shared_ptr<OrchestratorQueueItem>>::iterator OrchestratorQueue::FindIteratorById(const OrchestratorQueueItemId& comparisonQueueItemId)
     {
@@ -420,9 +439,37 @@ namespace AppInstaller::CLI::Execution
         m_queueEmpty.wait();
     }
 
-    bool OrchestratorQueue::WaitForEmptyQueue(DWORD timeoutMiliseconds)
+    bool OrchestratorQueue::WaitForEmptyQueue(DWORD timeoutMilliseconds)
+    {
+        return m_queueEmpty.wait(timeoutMilliseconds);
+    }
+
+    std::string OrchestratorQueue::GetStatusString()
     {
-        return m_queueEmpty.wait(timeoutMiliseconds);
+        std::ostringstream stream;
+        stream << m_commandName << '[' << m_allowedThreads << "]\n";
+
+        std::map<OrchestratorQueueItemState, size_t> stateCounts;
+        stateCounts[OrchestratorQueueItemState::NotQueued] = 0;
+        stateCounts[OrchestratorQueueItemState::Queued] = 0;
+        stateCounts[OrchestratorQueueItemState::Running] = 0;
+        stateCounts[OrchestratorQueueItemState::Cancelled] = 0;
+
+        {
+            std::lock_guard<std::mutex> lock{ m_itemLock };
+
+            for (const auto& item : m_queueItems)
+            {
+                stateCounts[item->GetState()] += 1;
+            }
+        }
+
+        for (const auto& stateCount : stateCounts)
+        {
+            stream << "  " << ToString(stateCount.first) << " : " << stateCount.second << std::endl;
+        }
+
+        return stream.str();
     }
 
     bool OrchestratorQueue::RemoveItemInState(const OrchestratorQueueItem& item, OrchestratorQueueItemState state, bool isGlobalRemove)
@@ -530,4 +577,16 @@ namespace AppInstaller::CLI::Execution
         item->AddCommand(std::make_unique<::AppInstaller::CLI::COMRepairCommand>(RootCommand::CommandName));
         return item;
     }
+
+    std::string_view ToString(OrchestratorQueueItemState state)
+    {
+        switch (state)
+        {
+        case OrchestratorQueueItemState::NotQueued: return "NotQueued";
+        case OrchestratorQueueItemState::Queued: return "Queued";
+        case OrchestratorQueueItemState::Running: return "Running";
+        case OrchestratorQueueItemState::Cancelled: return "Cancelled";
+        default: return "Unknown";
+        }
+    }
 }

src/AppInstallerCLICore/ContextOrchestrator.h

@@ -10,6 +10,7 @@
 #include "Command.h"
 #include "COMContext.h"
 #include <wil/resource.h>
+#include <string>
 #include <string_view>
 
 namespace AppInstaller::CLI::Execution
@@ -26,6 +27,8 @@ namespace AppInstaller::CLI::Execution
         Cancelled
     };
 
+    std::string_view ToString(OrchestratorQueueItemState state);
+
     struct OrchestratorQueueItemId
     {
         OrchestratorQueueItemId(std::wstring packageId, std::wstring sourceId) : m_packageId(std::move(packageId)), m_sourceId(std::move(sourceId)) {}
@@ -137,7 +140,10 @@ namespace AppInstaller::CLI::Execution
         // Waits for running items to complete; waits up to full time out in *each* queue.
         // Returns true to indicate all queues are empty before the timeout.
         // Intended for test use.
-        bool WaitForRunningItems(DWORD timeoutMiliseconds);
+        bool WaitForRunningItems(DWORD timeoutMilliseconds);
+
+        // Gets a string that represents the current state of the orchestrator.
+        std::string GetStatusString();
 
     private:
         std::mutex m_queueLock;
@@ -189,7 +195,10 @@ namespace AppInstaller::CLI::Execution
         // Waits until the empty queue event is signaled.
         // Returns true to indicate the queue is empty before the timeout.
         // Intended for tests.
-        bool WaitForEmptyQueue(DWORD timeoutMiliseconds);
+        bool WaitForEmptyQueue(DWORD timeoutMilliseconds);
+
+        // Gets a string that represents the current state of the queue.
+        std::string GetStatusString();
 
     private:
         // Enqueues an item.

src/AppInstallerCLIE2ETests/Interop/Shutdown.cs

@@ -48,7 +48,7 @@ public void NoActiveOperations()
             this.SendMessageAndLog(server, WindowMessage.EndSession);
             this.SendMessageAndLog(server, WindowMessage.Close);
 
-            Assert.IsTrue(server.Process.HasExited);
+            Assert.IsTrue(server.Process.WaitForExit(5000));
         }
 
         /// <summary>
@@ -84,7 +84,7 @@ public async Task ActiveInstallOperation()
             this.SendMessageAndLog(server, WindowMessage.EndSession);
             this.SendMessageAndLog(server, WindowMessage.Close);
 
-            Assert.IsTrue(server.Process.HasExited);
+            Assert.IsTrue(server.Process.WaitForExit(5000));
 
             var installResult = await installOperation;
 

src/AppInstallerCLITests/ContextOrchestrator.cpp

@@ -157,31 +157,50 @@ TEST_CASE("ContextOrchestrator_CancelAllItems", "[context_orchestrator]")
 
     auto downloadQueued = CreateTestItem("downloadQueued");
     auto downloadRunning = CreateTestItem("downloadRunning");
-    wil::slim_event_manual_reset downloadRunningEvent;
-    downloadRunning.Context->OperationCallback = [&]() { downloadRunningEvent.wait(); };
+    wil::slim_event_manual_reset downloadBegunEvent;
+    wil::slim_event_manual_reset downloadWaitingEvent;
+    downloadRunning.Context->DownloadCallback = [&]()
+        {
+            downloadBegunEvent.SetEvent();
+            downloadWaitingEvent.wait();
+        };
 
     auto operationQueued = CreateTestItem("operationQueued");
     auto operationRunning = CreateTestItem("operationRunning");
-    wil::slim_event_manual_reset operationRunningEvent;
-    operationRunning.Context->OperationCallback = [&]() { operationRunningEvent.wait(); };
+    wil::slim_event_manual_reset operationBegunEvent;
+    wil::slim_event_manual_reset operationWaitingEvent;
+    operationRunning.Context->OperationCallback = [&]()
+        {
+            operationBegunEvent.SetEvent();
+            operationWaitingEvent.wait();
+        };
 
     orchestrator.EnqueueAndRunItem(operationRunning.QueueItem);
     orchestrator.EnqueueAndRunItem(operationQueued.QueueItem);
     orchestrator.EnqueueAndRunItem(downloadRunning.QueueItem);
     orchestrator.EnqueueAndRunItem(downloadQueued.QueueItem);
 
+    operationBegunEvent.wait(c_DefaultWaitInMs);
+    downloadBegunEvent.wait(c_DefaultWaitInMs);
+
+    INFO("Pre-shutdown state: \n" << orchestrator.GetStatusString());
+
     auto reason = AppInstaller::CancelReason::AppShutdown;
     orchestrator.Disable(reason);
     orchestrator.CancelQueuedItems(reason);
 
-    operationRunningEvent.SetEvent();
-    downloadRunningEvent.SetEvent();
+    operationWaitingEvent.SetEvent();
+    downloadWaitingEvent.SetEvent();
 
-    REQUIRE(orchestrator.WaitForRunningItems(c_DefaultWaitInMs));
+    if (!orchestrator.WaitForRunningItems(c_DefaultWaitInMs))
+    {
+        INFO("Post-wait state: \n" << orchestrator.GetStatusString());
+        FAIL("Timed out waiting for orchestrator to empty");
+    }
 
     auto checkQueueItem = [](TestQueueItem& item)
         {
-            REQUIRE(item.QueueItem->GetCompletedEvent().wait(c_DefaultWaitInMs));
+            REQUIRE(item.QueueItem->GetCompletedEvent().wait(0));
             REQUIRE(item.Context->IsTerminated());
             REQUIRE(E_ABORT == item.Context->GetTerminationHR());
         };

src/Microsoft.Management.Configuration.UnitTests/Fixtures/UnitTestFixture.cs

@@ -7,6 +7,7 @@
 namespace Microsoft.Management.Configuration.UnitTests.Fixtures
 {
     using System;
+    using System.Diagnostics.CodeAnalysis;
     using System.IO;
     using System.Reflection;
     using Microsoft.Management.Configuration.Processor;
@@ -62,7 +63,7 @@ public UnitTestFixture(IMessageSink messageSink)
                 throw new DirectoryNotFoundException(this.ExternalModulesPath);
             }
 
-            this.ConfigurationStatics = new ConfigurationStaticFunctions().As<IConfigurationStatics2>();
+            this.RecreateStatics();
         }
 
         /// <summary>
@@ -88,7 +89,16 @@ public UnitTestFixture(IMessageSink messageSink)
         /// <summary>
         /// Gets the configuration statics object to use.
         /// </summary>
-        internal IConfigurationStatics2 ConfigurationStatics { get; private init; }
+        internal IConfigurationStatics2 ConfigurationStatics { get; private set; }
+
+        /// <summary>
+        /// Creates a new statics object for use by the tests.
+        /// </summary>
+        [MemberNotNull("ConfigurationStatics")]
+        public void RecreateStatics()
+        {
+            this.ConfigurationStatics = new ConfigurationStaticFunctions().As<IConfigurationStatics2>();
+        }
 
         /// <summary>
         /// Creates a runspace adding the test module path.

src/Microsoft.Management.Configuration.UnitTests/Tests/ShutdownTests.cs

@@ -38,6 +38,8 @@ public ShutdownTests(UnitTestFixture fixture, ITestOutputHelper log)
         [Fact]
         public void ShutdownSynchronization_SyncCall()
         {
+            this.Fixture.RecreateStatics();
+
             ConfigurationSet configurationSet = this.ConfigurationSet();
             ConfigurationUnit configurationUnitWaits = this.ConfigurationUnit();
             ConfigurationUnit configurationUnitWorks = this.ConfigurationUnit();
@@ -112,6 +114,8 @@ public void ShutdownSynchronization_SyncCall()
         [Fact]
         public void ShutdownSynchronization_AsyncCall()
         {
+            this.Fixture.RecreateStatics();
+
             ConfigurationSet configurationSet = this.ConfigurationSet();
             ConfigurationUnit configurationUnitWaits = this.ConfigurationUnit();
             ConfigurationUnit configurationUnitWorks = this.ConfigurationUnit();