File: Model\ResourceOrderStoreTests.cs
Web Access
Project: src\tests\Aspire.Dashboard.Tests\Aspire.Dashboard.Tests.csproj (Aspire.Dashboard.Tests)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Globalization;
using Aspire.Dashboard.Configuration;
using Aspire.Dashboard.Model;
using Aspire.Dashboard.Model.BrowserStorage;
using Aspire.Dashboard.Tests.Shared;
using Aspire.Dashboard.Utils;
using Aspire.Tests.Shared.DashboardModel;
using Google.Protobuf.WellKnownTypes;
using Microsoft.AspNetCore.InternalTesting;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Time.Testing;
using Xunit;
 
namespace Aspire.Dashboard.Tests.Model;
 
public sealed class ResourceOrderStoreTests
{
    private static readonly string s_storageKey = BrowserStorageKeys.ResourceOrderKey("TestApp");
 
    private readonly InMemoryBrowserLocalStorage _browser = new();
    private readonly FakeTimeProvider _timeProvider = new();
    private readonly LocalStorageLocks _locks = new();
 
    [Fact]
    public async Task AppHostDisplayOrdersSeedOrderingAndSavedMovesTakePrecedence()
    {
        var store = await CreateLoadedStoreAsync();
        var api = CreateResourceWithDisplayOrder("api", 10);
        var cache = CreateResourceWithDisplayOrder("cache", 20);
        var worker = ModelTestHelpers.CreateResource("worker");
        ResourceViewModel[] resources = [api, cache, worker];
        store.EnsureResources(resources.Select(r => r.PersistentKey));
 
        Assert.Equal([cache.PersistentKey, api.PersistentKey, worker.PersistentKey], GetOrderedKeys(store, resources));
 
        // A restart must not turn inferred order into a user customization. Higher orders come first and resources
        // without one count as 0, so a negative order moves cache after worker.
        store = await CreateLoadedStoreAsync();
        resources = [api, CreateResourceWithDisplayOrder("cache", -10), worker];
        store.EnsureResources(resources.Select(r => r.PersistentKey));
        Assert.Equal([api.PersistentKey, worker.PersistentKey, cache.PersistentKey], GetOrderedKeys(store, resources));
        Assert.True(store.TryMove(cache.PersistentKey, api.PersistentKey, false, resources));
 
        store = await CreateLoadedStoreAsync();
        store.EnsureResources(resources.Select(r => r.PersistentKey));
        Assert.Equal([cache.PersistentKey, api.PersistentKey, worker.PersistentKey], GetOrderedKeys(store, resources));
    }
 
    [Fact]
    public async Task DisplayOrdersAreScopedToTheRequestingRun()
    {
        var store = await CreateLoadedStoreAsync();
        ResourceViewModel[] liveRun = [CreateResourceWithDisplayOrder("api", 0), CreateResourceWithDisplayOrder("cache", 10)];
        ResourceViewModel[] recordedRun = [CreateResourceWithDisplayOrder("api", 10), CreateResourceWithDisplayOrder("cache", 0)];
        store.EnsureResources(liveRun.Select(r => r.PersistentKey));
 
        Assert.Equal(["api_0", "cache_0"], GetOrderedKeys(store, recordedRun));
        Assert.Equal(["cache_0", "api_0"], GetOrderedKeys(store, liveRun));
    }
 
    [Fact]
    public async Task ExplicitZeroDisplayOrder_KeepsStoredOrderLikeUnsetOrder()
    {
        var store = await CreateLoadedStoreAsync();
        // worker is stored after api. Treating its explicit 0 differently from api's unset order would move it first.
        ResourceViewModel[] resources =
        [
            ModelTestHelpers.CreateResource("api"),
            CreateResourceWithDisplayOrder("worker", 0),
            CreateResourceWithDisplayOrder("cache", 10),
            CreateResourceWithDisplayOrder("db", -10)
        ];
        store.EnsureResources(resources.Select(r => r.PersistentKey));
 
        Assert.Equal(["cache_0", "api_0", "worker_0", "db_0"], GetOrderedKeys(store, resources));
    }
 
    [Fact]
    public async Task TryMove_EqualDisplayOrders_UsesDisplayedOrder()
    {
        var store = await CreateLoadedStoreAsync();
        // Inserted out of name order, with b and a sharing a position. The pane displays a, b, c.
        ResourceViewModel[] resources =
        [
            CreateResourceWithDisplayOrder("b", 5, "Container"),
            CreateResourceWithDisplayOrder("a", 5, "Project"),
            CreateResourceWithDisplayOrder("c", -10, "Project")
        ];
        store.EnsureResources(resources.Select(r => r.PersistentKey));
 
        Assert.True(store.TryMove("c_0", "a_0", after: true, resources));
 
        Assert.Equal(["a_0", "c_0", "b_0"], GetOrderedKeys(store));
    }
 
    [Fact]
    public async Task GroupOrder_PersistsIndependentScopes()
    {
        var store = await CreateLoadedStoreAsync();
        store.EnsureResources(["cache_0", "api_0"]);
        store.EnsureGroups("Tags", ["Container", "Untagged", ""]);
        store.EnsureGroups("ResourceType", ["Container", "Project"]);
        store.EnsureGroups("State", ["Running", "Waiting"]);
        Assert.True(store.TryMoveGroup("Tags", "", "Container", after: false));
        Assert.True(store.TryMoveGroup("ResourceType", "Project", "Container", after: false));
        Assert.True(store.TryMoveGroup("State", "Waiting", "Running", after: false));
 
        Assert.Equal(
            """{"resources":["cache_0","api_0"],"groups":{"Tags":["","Container","Untagged"],"ResourceType":["Project","Container"],"State":["Waiting","Running"]},"customOrder":false}""",
            _browser.Items[s_storageKey]);
 
        var reloaded = await CreateLoadedStoreAsync();
        reloaded.EnsureGroups("Tags", ["Container", "A new group"]);
        Assert.Equal(["", "Container", "Untagged", "A new group"], GetOrderedGroupKeys(reloaded, "Tags"));
        Assert.Equal(["Project", "Container"], GetOrderedGroupKeys(reloaded, "ResourceType"));
        Assert.Equal(["Waiting", "Running"], GetOrderedGroupKeys(reloaded, "State"));
        Assert.Equal(["cache_0", "api_0"], GetOrderedKeys(reloaded));
        Assert.Equal(["", "Container", "Untagged", "A new group"], GetOrderedGroupKeys(await CreateLoadedStoreAsync(), "Tags"));
    }
 
    [Fact]
    public void GroupOrder_ConcurrentUpdatesKeepUniquePositionsInEachScope()
    {
        var store = CreateStore();
        Parallel.For(0, 100, i =>
        {
            store.EnsureGroups("Tags", [$"group_{i}", "shared"]);
            store.EnsureGroups("State", [$"group_{i}"]);
        });
 
        Assert.Equal(Enumerable.Range(0, 101).Select(i => (long)i), store.GetGroupPositions("Tags").Values.Order());
        Assert.Equal(Enumerable.Range(0, 100).Select(i => (long)i), store.GetGroupPositions("State").Values.Order());
        Assert.Empty(store.GetPositions());
    }
 
    [Fact]
    public async Task Order_PersistsAndAppendsNewResources()
    {
        var store = await CreateLoadedStoreAsync();
        store.EnsureResources(["api_0", "worker_0", "api_1"]);
        Assert.True(store.TryMove("api_1", "worker_0", after: false));
 
        var reloaded = await CreateLoadedStoreAsync();
        reloaded.EnsureResources(["worker_0", "new_0", "api_0"]);
        Assert.Equal(["api_0", "api_1", "worker_0", "new_0"], GetOrderedKeys(reloaded));
        Assert.Equal(["api_0", "api_1", "worker_0", "new_0"], GetOrderedKeys(await CreateLoadedStoreAsync()));
    }
 
    [Fact]
    public async Task Order_PositionsAssignedBeforeLoadFollowStoredPositions()
    {
        var store = await CreateLoadedStoreAsync();
        store.EnsureResources(["api_0", "worker_0"]);
        Assert.True(store.TryMove("worker_0", "api_0", after: false));
        store.EnsureGroups("State", ["Running"]);
 
        // Positions assigned before the stored order is read must not replace it.
        var reloaded = CreateStore();
        reloaded.EnsureResources(["new_0", "api_0"]);
        reloaded.EnsureGroups("State", ["Waiting"]);
        await reloaded.EnsureLoadedAsync().DefaultTimeout();
 
        Assert.Equal(["worker_0", "api_0", "new_0"], GetOrderedKeys(reloaded));
        Assert.Equal(["Running", "Waiting"], GetOrderedGroupKeys(reloaded, "State"));
        Assert.Equal("""{"resources":["worker_0","api_0","new_0"],"groups":{"State":["Running","Waiting"]},"customOrder":true}""", _browser.Items[s_storageKey]);
    }
 
    [Fact]
    public async Task Order_ChangesFromAnotherTabAreKept()
    {
        var tabA = await CreateLoadedStoreAsync();
        tabA.EnsureResources(["api_0", "cache_0", "worker_0"]);
        var tabB = await CreateLoadedStoreAsync();
        Assert.True(tabA.TryMove("worker_0", "api_0", after: false));
 
        // Tab B didn't see tab A's move. A new resource in tab B is added after the order tab A saved.
        tabB.EnsureResources(["new_0"]);
 
        Assert.Equal(["worker_0", "api_0", "cache_0", "new_0"], GetOrderedKeys(tabB));
        Assert.Equal("""{"resources":["worker_0","api_0","cache_0","new_0"],"groups":{},"customOrder":true}""", _browser.Items[s_storageKey]);
    }
 
    [Fact]
    public async Task Order_UnreadableStorageIsNotOverwritten()
    {
        var store = await CreateLoadedStoreAsync();
        store.EnsureResources(["api_0", "worker_0"]);
        var storedValue = _browser.Items[s_storageKey];
 
        _browser.FailReads = true;
        var reloaded = await CreateLoadedStoreAsync();
        reloaded.EnsureResources(["new_0"]);
 
        Assert.Equal(["new_0"], GetOrderedKeys(reloaded));
        Assert.Equal(storedValue, _browser.Items[s_storageKey]);
    }
 
    [Fact]
    public async Task Order_InvalidStoredValueIsKeptAndReplaced()
    {
        _browser.Items[s_storageKey] = "[1, 2]";
        var store = await CreateLoadedStoreAsync();
        store.EnsureResources(["api_0"]);
 
        Assert.Equal(["api_0"], GetOrderedKeys(store));
        Assert.Equal("""{"resources":["api_0"],"groups":{},"customOrder":false}""", _browser.Items[s_storageKey]);
        Assert.Equal("[1, 2]", _browser.Items[$"{s_storageKey}_Unreadable"]);
    }
 
    [Fact]
    public void Order_SupportsMovingBeforeAndAfter()
    {
        var store = CreateStore();
        var changes = 0;
        store.Changed += () => changes++;
        store.EnsureResources(["api_0", "cache_0", "worker_0"]);
        Assert.True(store.TryMove("worker_0", "api_0", after: false));
        Assert.Equal(["worker_0", "api_0", "cache_0"], GetOrderedKeys(store));
        Assert.True(store.TryMove("WORKER_0", "CACHE_0", after: true));
        Assert.True(store.TryMove("api_0", "API_0", after: false));
        Assert.Equal(["api_0", "cache_0", "WORKER_0"], GetOrderedKeys(store));
        Assert.Equal(3, changes);
    }
 
    [Fact]
    public void EnsureResources_RetainsAbsentResourcesAndDoesNotDuplicateKeys()
    {
        var store = CreateStore();
        store.EnsureResources(["API_0", "worker_0", "worker_1"]);
        store.EnsureResources(["WORKER_0", "new_0", "NEW_0"]);
        Assert.Equal(["API_0", "worker_0", "worker_1", "new_0"], GetOrderedKeys(store));
    }
 
    [Fact]
    public void EnsureResources_ConcurrentUpdatesHaveUniquePositions()
    {
        var store = CreateStore();
        Parallel.For(0, 100, i => store.EnsureResources([$"resource_{i}", "shared_0"]));
 
        var positions = store.GetPositions();
        Assert.Equal(101, positions.Count);
        Assert.Equal(Enumerable.Range(0, 101).Select(i => (long)i), positions.Values.Order());
        Assert.All(Enumerable.Range(0, 100), i => Assert.True(positions.ContainsKey($"resource_{i}")));
    }
 
    [Fact]
    public void TryMove_UnknownKeyIsRejected()
    {
        var store = CreateStore();
        store.EnsureResources(["api_0"]);
 
        Assert.False(store.TryMove("missing_0", "api_0", after: false));
        Assert.Equal(["api_0"], GetOrderedKeys(store));
    }
 
    private static ResourceViewModel CreateResourceWithDisplayOrder(string name, int order, string resourceType = "Container") =>
        ModelTestHelpers.CreateResource(name, resourceType: resourceType, properties: new()
        {
            [KnownProperties.Resource.DisplayOrder] = new(KnownProperties.Resource.DisplayOrder, Value.ForString(order.ToString(CultureInfo.InvariantCulture)), false, null, 0, null, false)
        });
 
    private static string[] GetOrderedKeys(ResourceOrderStore store, IEnumerable<ResourceViewModel> resources) =>
        store.GetPositions(resources).OrderBy(pair => pair.Value).Select(pair => pair.Key).ToArray();
 
    private static string[] GetOrderedKeys(ResourceOrderStore store) =>
        store.GetPositions().OrderBy(pair => pair.Value).Select(pair => pair.Key).ToArray();
 
    private static string[] GetOrderedGroupKeys(ResourceOrderStore store, string grouping) =>
        store.GetGroupPositions(grouping).OrderBy(pair => pair.Value).Select(pair => pair.Key).ToArray();
 
    private ResourceOrderStore CreateStore() =>
        new(_browser.Storage, _locks, _timeProvider, Options.Create(new DashboardOptions { ApplicationName = "TestApp" }), NullLogger<ResourceOrderStore>.Instance);
 
    private async Task<ResourceOrderStore> CreateLoadedStoreAsync()
    {
        var store = CreateStore();
        await store.EnsureLoadedAsync().DefaultTimeout();
        return store;
    }
}