Expose TestUnit method to COM API (microsoft#5520)

This pull request introduces a new feature to test configuration units
in the `ConfigurationProcessor` class. The most important changes
include the addition of synchronous and asynchronous methods for testing
configuration units, along with their implementation and interface
definitions.

Author: t-ggarzia-MSFT

src/Microsoft.Management.Configuration/ConfigurationProcessor.cpp

@@ -1065,6 +1065,71 @@ namespace winrt::Microsoft::Management::Configuration::implementation
         return *result;
     }
 
+    Configuration::TestConfigurationUnitResult ConfigurationProcessor::TestUnit(const ConfigurationUnit& unit)
+    {
+        THROW_HR_IF(E_NOT_VALID_STATE, !m_factory);
+        return TestUnitImpl(unit);
+    }
+
+    Windows::Foundation::IAsyncOperation<Configuration::TestConfigurationUnitResult> ConfigurationProcessor::TestUnitAsync(const ConfigurationUnit& unit)
+    {
+        THROW_HR_IF(E_NOT_VALID_STATE, !m_factory);
+
+        auto strong_this{ get_strong() };
+        ConfigurationUnit localUnit = unit;
+
+        co_await winrt::resume_background();
+
+        co_return TestUnitImpl(localUnit, { co_await winrt::get_cancellation_token() });
+    }
+
+    Configuration::TestConfigurationUnitResult ConfigurationProcessor::TestUnitImpl(
+        const ConfigurationUnit& unit,
+        AppInstaller::WinRT::AsyncCancellation cancellation)
+    {
+        auto threadGlobals = m_threadGlobals.SetForCurrentThread();
+
+        IConfigurationSetProcessor setProcessor = m_factory.CreateSetProcessor(nullptr);
+        auto result = make_self<wil::details::module_count_wrapper<implementation::TestConfigurationUnitResult>>();
+        auto unitResult = make_self<wil::details::module_count_wrapper<implementation::ConfigurationUnitResultInformation>>();
+        result->Unit(unit);
+        result->ResultInformation(*unitResult);
+
+        cancellation.ThrowIfCancelled();
+
+        IConfigurationUnitProcessor unitProcessor;
+
+        try
+        {
+            unitProcessor = setProcessor.CreateUnitProcessor(unit);
+        }
+        catch (...)
+        {
+            ExtractUnitResultInformation(std::current_exception(), unitResult);
+        }
+
+        cancellation.ThrowIfCancelled();
+
+        if (unitProcessor)
+        {
+            try
+            {
+                auto testResult = unitProcessor.TestSettings();
+                result->Unit(testResult.Unit());
+                result->TestResult(testResult.TestResult());
+                result->ResultInformation(testResult.ResultInformation());
+            }
+            catch (...)
+            {
+                ExtractUnitResultInformation(std::current_exception(), unitResult);
+            }
+
+            m_threadGlobals.GetTelemetryLogger().LogConfigUnitRunIfAppropriate(GUID_NULL, unit, ConfigurationUnitIntent::Assert, TelemetryTraceLogger::TestAction, result->ResultInformation());
+        }
+
+        return *result;
+    }
+
     IConfigurationGroupProcessor ConfigurationProcessor::GetSetGroupProcessor(const Configuration::ConfigurationSet& configurationSet)
     {
         IConfigurationSetProcessor setProcessor = m_factory.CreateSetProcessor(configurationSet);

src/Microsoft.Management.Configuration/ConfigurationProcessor.h

@@ -92,6 +92,9 @@ namespace winrt::Microsoft::Management::Configuration::implementation
 
         Configuration::ApplyConfigurationUnitResult ApplyUnit(const ConfigurationUnit& unit);
         Windows::Foundation::IAsyncOperation<Configuration::ApplyConfigurationUnitResult> ApplyUnitAsync(const ConfigurationUnit& unit);
+        
+        Configuration::TestConfigurationUnitResult TestUnit(const ConfigurationUnit& unit);
+        Windows::Foundation::IAsyncOperation<Configuration::TestConfigurationUnitResult> TestUnitAsync(const ConfigurationUnit& unit);
 
         HRESULT STDMETHODCALLTYPE SetLifetimeWatcher(IUnknown* watcher);
 
@@ -136,6 +139,8 @@ namespace winrt::Microsoft::Management::Configuration::implementation
 
         Configuration::ApplyConfigurationUnitResult ApplyUnitImpl(const ConfigurationUnit& unit, AppInstaller::WinRT::AsyncCancellation cancellation = {});
 
+        Configuration::TestConfigurationUnitResult TestUnitImpl(const ConfigurationUnit& unit, AppInstaller::WinRT::AsyncCancellation cancellation = {});
+
         IConfigurationGroupProcessor GetSetGroupProcessor(const Configuration::ConfigurationSet& configurationSet);
 
         void SendDiagnosticsImpl(const IDiagnosticInformation& information);

src/Microsoft.Management.Configuration/Microsoft.Management.Configuration.idl

@@ -1028,6 +1028,10 @@ namespace Microsoft.Management.Configuration
             // Apply the current configuration unit.
             ApplyConfigurationUnitResult ApplyUnit(ConfigurationUnit unit);
             Windows.Foundation.IAsyncOperation<ApplyConfigurationUnitResult> ApplyUnitAsync(ConfigurationUnit unit);
+            
+            // Test the current configuration unit.
+            TestConfigurationUnitResult TestUnit(ConfigurationUnit unit);
+            Windows.Foundation.IAsyncOperation<TestConfigurationUnitResult> TestUnitAsync(ConfigurationUnit unit);
         }
     }