[CmdPal][UnitTests] Add/Migrate unit test for Apps and Bookmarks extension (#41238)

<!-- Enter a brief description/summary of your PR here. What does it
fix/what does it change/how was it tested (even manually, if necessary)?
-->
## Summary of the Pull Request
1. Create Apps and Bookmarks ut project.
2. Refactor Apps and Bookmarks. And some interface in these extensions
to add a abstraction layer for testing purpose.
New interface list:
* ISettingsInterface
* IUWPApplication
* IAppCache
* IBookmarkDataSource
3. Add/Migrate some test case for Apps and Bookmarks extension

<!-- Please review the items on the PR checklist before submitting-->
## PR Checklist

- [x] Closes: #41239 #41240
- [x] **Communication:** I've discussed this with core contributors
already. If the work hasn't been agreed, this work might be rejected
- [x] **Tests:** Added/updated and all pass
- [ ] **Localization:** All end-user-facing strings can be localized
- [ ] **Dev docs:** Added/updated
- [ ] **New binaries:** Added on the required places
- [ ] [JSON for
signing](https://github.com/microsoft/PowerToys/blob/main/.pipelines/ESRPSigning_core.json)
for new binaries
- [ ] [WXS for
installer](https://github.com/microsoft/PowerToys/blob/main/installer/PowerToysSetup/Product.wxs)
for new binaries and localization folder
- [ ] [YML for CI
pipeline](https://github.com/microsoft/PowerToys/blob/main/.pipelines/ci/templates/build-powertoys-steps.yml)
for new test projects
- [ ] [YML for signed
pipeline](https://github.com/microsoft/PowerToys/blob/main/.pipelines/release.yml)
- [ ] **Documentation updated:** If checked, please file a pull request
on [our docs
repo](https://github.com/MicrosoftDocs/windows-uwp/tree/docs/hub/powertoys)
and link it here: #xxx

<!-- Provide a more detailed description of the PR, other things fixed,
or any additional comments/features here -->
## Detailed Description of the Pull Request / Additional comments

<!-- Describe how you validated the behavior. Add automated tests
wherever possible, but list manual validation steps taken as well -->
## Validation Steps Performed

---------

Co-authored-by: Yu Leng <yuleng@microsoft.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/AllAppsCommandProviderTests.cs

@@ -0,0 +1,119 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Apps.UnitTests;
+
+[TestClass]
+public class AllAppsCommandProviderTests : AppsTestBase
+{
+    [TestMethod]
+    public void ProviderHasDisplayName()
+    {
+        // Setup
+        var provider = new AllAppsCommandProvider();
+
+        // Assert
+        Assert.IsNotNull(provider.DisplayName);
+        Assert.IsTrue(provider.DisplayName.Length > 0);
+    }
+
+    [TestMethod]
+    public void ProviderHasIcon()
+    {
+        // Setup
+        var provider = new AllAppsCommandProvider();
+
+        // Assert
+        Assert.IsNotNull(provider.Icon);
+    }
+
+    [TestMethod]
+    public void TopLevelCommandsNotEmpty()
+    {
+        // Setup
+        var provider = new AllAppsCommandProvider();
+
+        // Act
+        var commands = provider.TopLevelCommands();
+
+        // Assert
+        Assert.IsNotNull(commands);
+        Assert.IsTrue(commands.Length > 0);
+    }
+
+    [TestMethod]
+    public void LookupAppWithEmptyNameReturnsNotNull()
+    {
+        // Setup
+        var mockApp = TestDataHelper.CreateTestWin32Program("Notepad", "C:\\Windows\\System32\\notepad.exe");
+        MockCache.AddWin32Program(mockApp);
+        var page = new AllAppsPage(MockCache);
+
+        var provider = new AllAppsCommandProvider(page);
+
+        // Act
+        var result = provider.LookupApp(string.Empty);
+
+        // Assert
+        Assert.IsNotNull(result);
+    }
+
+    [TestMethod]
+    public async Task ProviderWithMockData_LookupApp_ReturnsCorrectApp()
+    {
+        // Arrange
+        var testApp = TestDataHelper.CreateTestWin32Program("TestApp", "C:\\TestApp.exe");
+        MockCache.AddWin32Program(testApp);
+
+        var provider = new AllAppsCommandProvider(Page);
+
+        // Wait for initialization to complete
+        await WaitForPageInitializationAsync();
+
+        // Act
+        var result = provider.LookupApp("TestApp");
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual("TestApp", result.Title);
+    }
+
+    [TestMethod]
+    public async Task ProviderWithMockData_LookupApp_ReturnsNullForNonExistentApp()
+    {
+        // Arrange
+        var testApp = TestDataHelper.CreateTestWin32Program("TestApp", "C:\\TestApp.exe");
+        MockCache.AddWin32Program(testApp);
+
+        var provider = new AllAppsCommandProvider(Page);
+
+        // Wait for initialization to complete
+        await WaitForPageInitializationAsync();
+
+        // Act
+        var result = provider.LookupApp("NonExistentApp");
+
+        // Assert
+        Assert.IsNull(result);
+    }
+
+    [TestMethod]
+    public void ProviderWithMockData_TopLevelCommands_IncludesListItem()
+    {
+        // Arrange
+        var provider = new AllAppsCommandProvider(Page);
+
+        // Act
+        var commands = provider.TopLevelCommands();
+
+        // Assert
+        Assert.IsNotNull(commands);
+        Assert.IsTrue(commands.Length >= 1); // At least the list item should be present
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/AllAppsPageTests.cs

@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Apps.UnitTests;
+
+[TestClass]
+public class AllAppsPageTests : AppsTestBase
+{
+    [TestMethod]
+    public void AllAppsPage_Constructor_ThrowsOnNullAppCache()
+    {
+        // Act & Assert
+        Assert.ThrowsException<ArgumentNullException>(() => new AllAppsPage(null!));
+    }
+
+    [TestMethod]
+    public void AllAppsPage_WithMockCache_InitializesSuccessfully()
+    {
+        // Arrange
+        var mockCache = new MockAppCache();
+
+        // Act
+        var page = new AllAppsPage(mockCache);
+
+        // Assert
+        Assert.IsNotNull(page);
+        Assert.IsNotNull(page.Name);
+        Assert.IsNotNull(page.Icon);
+    }
+
+    [TestMethod]
+    public async Task AllAppsPage_GetItems_ReturnsEmptyWithEmptyCache()
+    {
+        // Act - Wait for initialization to complete
+        await WaitForPageInitializationAsync();
+        var items = Page.GetItems();
+
+        // Assert
+        Assert.IsNotNull(items);
+        Assert.AreEqual(0, items.Length);
+    }
+
+    [TestMethod]
+    public async Task AllAppsPage_GetItems_ReturnsAppsFromCacheAsync()
+    {
+        // Arrange
+        var mockCache = new MockAppCache();
+        var win32App = TestDataHelper.CreateTestWin32Program("Notepad", "C:\\Windows\\System32\\notepad.exe");
+        var uwpApp = TestDataHelper.CreateTestUWPApplication("Calculator");
+
+        mockCache.AddWin32Program(win32App);
+        mockCache.AddUWPApplication(uwpApp);
+
+        var page = new AllAppsPage(mockCache);
+
+        // Wait a bit for initialization to complete
+        await Task.Delay(100);
+
+        // Act
+        var items = page.GetItems();
+
+        // Assert
+        Assert.IsNotNull(items);
+        Assert.AreEqual(2, items.Length);
+
+        // we need to loop the items to ensure we got the correct ones
+        Assert.IsTrue(items.Any(i => i.Title == "Notepad"));
+        Assert.IsTrue(items.Any(i => i.Title == "Calculator"));
+    }
+
+    [TestMethod]
+    public async Task AllAppsPage_GetPinnedApps_ReturnsEmptyWhenNoAppsArePinned()
+    {
+        // Arrange
+        var mockCache = new MockAppCache();
+        var app = TestDataHelper.CreateTestWin32Program("TestApp", "C:\\TestApp.exe");
+        mockCache.AddWin32Program(app);
+
+        var page = new AllAppsPage(mockCache);
+
+        // Wait a bit for initialization to complete
+        await Task.Delay(100);
+
+        // Act
+        var pinnedApps = page.GetPinnedApps();
+
+        // Assert
+        Assert.IsNotNull(pinnedApps);
+        Assert.AreEqual(0, pinnedApps.Length);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/AppsTestBase.cs

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Apps.UnitTests;
+
+/// <summary>
+/// Base class for Apps unit tests that provides common setup and teardown functionality.
+/// </summary>
+public abstract class AppsTestBase
+{
+    /// <summary>
+    /// Gets the mock application cache used in tests.
+    /// </summary>
+    protected MockAppCache MockCache { get; private set; } = null!;
+
+    /// <summary>
+    /// Gets the AllAppsPage instance used in tests.
+    /// </summary>
+    protected AllAppsPage Page { get; private set; } = null!;
+
+    /// <summary>
+    /// Sets up the test environment before each test method.
+    /// </summary>
+    /// <returns>A task representing the asynchronous setup operation.</returns>
+    [TestInitialize]
+    public virtual async Task Setup()
+    {
+        MockCache = new MockAppCache();
+        Page = new AllAppsPage(MockCache);
+
+        // Ensure initialization is complete
+        await MockCache.RefreshAsync();
+    }
+
+    /// <summary>
+    /// Cleans up the test environment after each test method.
+    /// </summary>
+    [TestCleanup]
+    public virtual void Cleanup()
+    {
+        MockCache?.Dispose();
+    }
+
+    /// <summary>
+    /// Forces synchronous initialization of the page for testing.
+    /// </summary>
+    protected void EnsurePageInitialized()
+    {
+        // Trigger BuildListItems by accessing items
+        _ = Page.GetItems();
+    }
+
+    /// <summary>
+    /// Waits for page initialization with timeout.
+    /// </summary>
+    /// <param name="timeoutMs">The timeout in milliseconds.</param>
+    /// <returns>A task representing the asynchronous wait operation.</returns>
+    protected async Task WaitForPageInitializationAsync(int timeoutMs = 1000)
+    {
+        await MockCache.RefreshAsync();
+        EnsurePageInitialized();
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/Microsoft.CmdPal.Ext.Apps.UnitTests.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Look at Directory.Build.props in root for common stuff as well -->
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <RootNamespace>Microsoft.CmdPal.Ext.Apps.UnitTests</RootNamespace>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Moq" />
+    <PackageReference Include="MSTest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.Apps\Microsoft.CmdPal.Ext.Apps.csproj" />
+    <ProjectReference Include="..\Microsoft.CmdPal.Ext.UnitTestsBase\Microsoft.CmdPal.Ext.UnitTestBase.csproj" />
+  </ItemGroup>
+</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/MockAppCache.cs

@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+
+namespace Microsoft.CmdPal.Ext.Apps.UnitTests;
+
+/// <summary>
+/// Mock implementation of IAppCache for unit testing.
+/// </summary>
+public class MockAppCache : IAppCache
+{
+    private readonly List<Win32Program> _win32s = new();
+    private readonly List<IUWPApplication> _uwps = new();
+    private bool _disposed;
+    private bool _shouldReload;
+
+    /// <summary>
+    /// Gets the collection of Win32 programs.
+    /// </summary>
+    public IList<Win32Program> Win32s => _win32s.AsReadOnly();
+
+    /// <summary>
+    /// Gets the collection of UWP applications.
+    /// </summary>
+    public IList<IUWPApplication> UWPs => _uwps.AsReadOnly();
+
+    /// <summary>
+    /// Determines whether the cache should be reloaded.
+    /// </summary>
+    /// <returns>True if cache should be reloaded, false otherwise.</returns>
+    public bool ShouldReload() => _shouldReload;
+
+    /// <summary>
+    /// Resets the reload flag.
+    /// </summary>
+    public void ResetReloadFlag() => _shouldReload = false;
+
+    /// <summary>
+    /// Asynchronously refreshes the cache.
+    /// </summary>
+    /// <returns>A task representing the asynchronous refresh operation.</returns>
+    public async Task RefreshAsync()
+    {
+        // Simulate minimal async operation for testing
+        await Task.Delay(1);
+    }
+
+    /// <summary>
+    /// Adds a Win32 program to the cache.
+    /// </summary>
+    /// <param name="program">The Win32 program to add.</param>
+    /// <exception cref="ArgumentNullException">Thrown when program is null.</exception>
+    public void AddWin32Program(Win32Program program)
+    {
+        ArgumentNullException.ThrowIfNull(program);
+
+        _win32s.Add(program);
+    }
+
+    /// <summary>
+    /// Adds a UWP application to the cache.
+    /// </summary>
+    /// <param name="app">The UWP application to add.</param>
+    /// <exception cref="ArgumentNullException">Thrown when app is null.</exception>
+    public void AddUWPApplication(IUWPApplication app)
+    {
+        ArgumentNullException.ThrowIfNull(app);
+
+        _uwps.Add(app);
+    }
+
+    /// <summary>
+    /// Clears all applications from the cache.
+    /// </summary>
+    public void ClearAll()
+    {
+        _win32s.Clear();
+        _uwps.Clear();
+    }
+
+    /// <summary>
+    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+    /// </summary>
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Releases unmanaged and - optionally - managed resources.
+    /// </summary>
+    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!_disposed)
+        {
+            if (disposing)
+            {
+                // Clean up managed resources
+                _win32s.Clear();
+                _uwps.Clear();
+            }
+
+            _disposed = true;
+        }
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/MockUWPApplication.cs

@@ -0,0 +1,140 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+using Microsoft.CmdPal.Ext.Apps.Utils;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps.UnitTests;
+
+/// <summary>
+/// Mock implementation of IUWPApplication for unit testing.
+/// </summary>
+public class MockUWPApplication : IUWPApplication
+{
+    /// <summary>
+    /// Gets or sets the app list entry.
+    /// </summary>
+    public string AppListEntry { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the unique identifier.
+    /// </summary>
+    public string UniqueIdentifier { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the display name.
+    /// </summary>
+    public string DisplayName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    public string Description { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the user model ID.
+    /// </summary>
+    public string UserModelId { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the background color.
+    /// </summary>
+    public string BackgroundColor { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the entry point.
+    /// </summary>
+    public string EntryPoint { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the application is enabled.
+    /// </summary>
+    public bool Enabled { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the application can run elevated.
+    /// </summary>
+    public bool CanRunElevated { get; set; }
+
+    /// <summary>
+    /// Gets or sets the logo path.
+    /// </summary>
+    public string LogoPath { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the logo type.
+    /// </summary>
+    public LogoType LogoType { get; set; } = LogoType.Colored;
+
+    /// <summary>
+    /// Gets or sets the UWP package.
+    /// </summary>
+    public UWP Package { get; set; } = null!;
+
+    /// <summary>
+    /// Gets the name of the application.
+    /// </summary>
+    public string Name => DisplayName;
+
+    /// <summary>
+    /// Gets the location of the application.
+    /// </summary>
+    public string Location => Package?.Location ?? string.Empty;
+
+    /// <summary>
+    /// Gets the localized location of the application.
+    /// </summary>
+    public string LocationLocalized => Package?.LocationLocalized ?? string.Empty;
+
+    /// <summary>
+    /// Gets the application identifier.
+    /// </summary>
+    /// <returns>The user model ID of the application.</returns>
+    public string GetAppIdentifier()
+    {
+        return UserModelId;
+    }
+
+    /// <summary>
+    /// Gets the commands available for this application.
+    /// </summary>
+    /// <returns>A list of context items.</returns>
+    public List<IContextItem> GetCommands()
+    {
+        return new List<IContextItem>();
+    }
+
+    /// <summary>
+    /// Updates the logo path based on the specified theme.
+    /// </summary>
+    /// <param name="theme">The theme to use for the logo.</param>
+    public void UpdateLogoPath(Theme theme)
+    {
+        // Mock implementation - no-op for testing
+    }
+
+    /// <summary>
+    /// Converts this UWP application to an AppItem.
+    /// </summary>
+    /// <returns>An AppItem representation of this UWP application.</returns>
+    public AppItem ToAppItem()
+    {
+        var iconPath = LogoType != LogoType.Error ? LogoPath : string.Empty;
+        return new AppItem()
+        {
+            Name = Name,
+            Subtitle = Description,
+            Type = "Packaged Application", // Equivalent to UWPApplication.Type()
+            IcoPath = iconPath,
+            DirPath = Location,
+            UserModelId = UserModelId,
+            IsPackaged = true,
+            Commands = GetCommands(),
+            AppIdentifier = GetAppIdentifier(),
+        };
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/QueryTests.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using Microsoft.CmdPal.Ext.UnitTestBase;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Apps.UnitTests;
+
+[TestClass]
+public class QueryTests : CommandPaletteUnitTestBase
+{
+    [TestMethod]
+    public void QueryReturnsExpectedResults()
+    {
+        // Arrange
+        var mockCache = new MockAppCache();
+        var win32App = TestDataHelper.CreateTestWin32Program("Notepad", "C:\\Windows\\System32\\notepad.exe");
+        var uwpApp = TestDataHelper.CreateTestUWPApplication("Calculator");
+        mockCache.AddWin32Program(win32App);
+        mockCache.AddUWPApplication(uwpApp);
+
+        for (var i = 0; i < 10; i++)
+        {
+            mockCache.AddWin32Program(TestDataHelper.CreateTestWin32Program($"App{i}"));
+            mockCache.AddUWPApplication(TestDataHelper.CreateTestUWPApplication($"UWP App {i}"));
+        }
+
+        var page = new AllAppsPage(mockCache);
+        var provider = new AllAppsCommandProvider(page);
+
+        // Act
+        var allItems = page.GetItems();
+
+        // Assert
+        var notepadResult = Query("notepad", allItems).FirstOrDefault();
+        Assert.IsNotNull(notepadResult);
+        Assert.AreEqual("Notepad", notepadResult.Title);
+
+        var calculatorResult = Query("cal", allItems).FirstOrDefault();
+        Assert.IsNotNull(calculatorResult);
+        Assert.AreEqual("Calculator", calculatorResult.Title);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/Settings.cs

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using Microsoft.CmdPal.Ext.Apps.Helpers;
+
+namespace Microsoft.CmdPal.Ext.Apps.UnitTests;
+
+public class Settings : ISettingsInterface
+{
+    private readonly bool enableStartMenuSource;
+    private readonly bool enableDesktopSource;
+    private readonly bool enableRegistrySource;
+    private readonly bool enablePathEnvironmentVariableSource;
+    private readonly List<string> programSuffixes;
+    private readonly List<string> runCommandSuffixes;
+
+    public Settings(
+        bool enableStartMenuSource = true,
+        bool enableDesktopSource = true,
+        bool enableRegistrySource = true,
+        bool enablePathEnvironmentVariableSource = true,
+        List<string> programSuffixes = null,
+        List<string> runCommandSuffixes = null)
+    {
+        this.enableStartMenuSource = enableStartMenuSource;
+        this.enableDesktopSource = enableDesktopSource;
+        this.enableRegistrySource = enableRegistrySource;
+        this.enablePathEnvironmentVariableSource = enablePathEnvironmentVariableSource;
+        this.programSuffixes = programSuffixes ?? new List<string> { "bat", "appref-ms", "exe", "lnk", "url" };
+        this.runCommandSuffixes = runCommandSuffixes ?? new List<string> { "bat", "appref-ms", "exe", "lnk", "url", "cpl", "msc" };
+    }
+
+    public bool EnableStartMenuSource => enableStartMenuSource;
+
+    public bool EnableDesktopSource => enableDesktopSource;
+
+    public bool EnableRegistrySource => enableRegistrySource;
+
+    public bool EnablePathEnvironmentVariableSource => enablePathEnvironmentVariableSource;
+
+    public List<string> ProgramSuffixes => programSuffixes;
+
+    public List<string> RunCommandSuffixes => runCommandSuffixes;
+
+    public static Settings CreateDefaultSettings() => new Settings();
+
+    public static Settings CreateDisabledSourcesSettings() => new Settings(
+        enableStartMenuSource: false,
+        enableDesktopSource: false,
+        enableRegistrySource: false,
+        enablePathEnvironmentVariableSource: false);
+
+    public static Settings CreateCustomSuffixesSettings() => new Settings(
+        programSuffixes: new List<string> { "exe", "bat" },
+        runCommandSuffixes: new List<string> { "exe", "bat", "cmd" });
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/TestDataHelper.cs

@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.Ext.Apps.Programs;
+
+namespace Microsoft.CmdPal.Ext.Apps.UnitTests;
+
+/// <summary>
+/// Helper class to create test data for unit tests.
+/// </summary>
+public static class TestDataHelper
+{
+    /// <summary>
+    /// Creates a test Win32 program with the specified parameters.
+    /// </summary>
+    /// <param name="name">The name of the application.</param>
+    /// <param name="fullPath">The full path to the application executable.</param>
+    /// <param name="enabled">A value indicating whether the application is enabled.</param>
+    /// <param name="valid">A value indicating whether the application is valid.</param>
+    /// <returns>A new Win32Program instance with the specified parameters.</returns>
+    public static Win32Program CreateTestWin32Program(
+        string name = "Test App",
+        string fullPath = "C:\\TestApp\\app.exe",
+        bool enabled = true,
+        bool valid = true)
+    {
+        return new Win32Program
+        {
+            Name = name,
+            FullPath = fullPath,
+            Enabled = enabled,
+            Valid = valid,
+            UniqueIdentifier = $"win32_{name}",
+            Description = $"Test description for {name}",
+            ExecutableName = "app.exe",
+            ParentDirectory = "C:\\TestApp",
+            AppType = Win32Program.ApplicationType.Win32Application,
+        };
+    }
+
+    /// <summary>
+    /// Creates a test UWP application with the specified parameters.
+    /// </summary>
+    /// <param name="displayName">The display name of the application.</param>
+    /// <param name="userModelId">The user model ID of the application.</param>
+    /// <param name="enabled">A value indicating whether the application is enabled.</param>
+    /// <returns>A new IUWPApplication instance with the specified parameters.</returns>
+    public static IUWPApplication CreateTestUWPApplication(
+        string displayName = "Test UWP App",
+        string userModelId = "TestPublisher.TestUWPApp_1.0.0.0_neutral__8wekyb3d8bbwe",
+        bool enabled = true)
+    {
+        return new MockUWPApplication
+        {
+            DisplayName = displayName,
+            UserModelId = userModelId,
+            Enabled = enabled,
+            UniqueIdentifier = $"uwp_{userModelId}",
+            Description = $"Test UWP description for {displayName}",
+            AppListEntry = "default",
+            BackgroundColor = "#000000",
+            EntryPoint = "TestApp.App",
+            CanRunElevated = false,
+            LogoPath = string.Empty,
+            Package = CreateMockUWPPackage(displayName, userModelId),
+        };
+    }
+
+    /// <summary>
+    /// Creates a mock UWP package for testing purposes.
+    /// </summary>
+    /// <param name="displayName">The display name of the package.</param>
+    /// <param name="userModelId">The user model ID of the package.</param>
+    /// <returns>A new UWP package instance.</returns>
+    private static UWP CreateMockUWPPackage(string displayName, string userModelId)
+    {
+        var mockPackage = new MockPackage
+        {
+            Name = displayName,
+            FullName = userModelId,
+            FamilyName = $"{displayName}_8wekyb3d8bbwe",
+            InstalledLocation = $"C:\\Program Files\\WindowsApps\\{displayName}",
+        };
+
+        return new UWP(mockPackage)
+        {
+            Location = mockPackage.InstalledLocation,
+            LocationLocalized = mockPackage.InstalledLocation,
+        };
+    }
+
+    /// <summary>
+    /// Mock implementation of IPackage for testing purposes.
+    /// </summary>
+    private sealed class MockPackage : IPackage
+    {
+        /// <summary>
+        /// Gets or sets the name of the package.
+        /// </summary>
+        public string Name { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets the full name of the package.
+        /// </summary>
+        public string FullName { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets the family name of the package.
+        /// </summary>
+        public string FamilyName { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the package is a framework package.
+        /// </summary>
+        public bool IsFramework { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the package is in development mode.
+        /// </summary>
+        public bool IsDevelopmentMode { get; set; }
+
+        /// <summary>
+        /// Gets or sets the installed location of the package.
+        /// </summary>
+        public string InstalledLocation { get; set; } = string.Empty;
+    }
+}