File: Model\ResourceTagStoreTests.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 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 ResourceTagStoreTests
{
    private static readonly string s_storageKey = BrowserStorageKeys.ResourceTagsKey("TestApp");
 
    private readonly InMemoryBrowserLocalStorage _browser = new();
    private readonly FakeTimeProvider _timeProvider = new();
    private readonly LocalStorageLocks _locks = new();
 
    [Fact]
    public void AppHostTagsAreMergedWithoutPersistingDeclaredTags()
    {
        var store = CreateStore();
        store.AddTag("api", "backend");
        store.AddTag("api", "Personal");
        var name = KnownProperties.Resource.TraitPrefix + KnownResourceTraits.Tag;
        var resource = ModelTestHelpers.CreateResource("api", properties: new()
        {
            [name] = new(name, Value.ForList(Value.ForString("Backend"), Value.ForString("API")), false, null, 0, null, false)
        });
 
        Assert.Equal(["Backend", "API", "Personal"], store.GetTagsByResource([resource])["api"]);
        Assert.Equal(["API", "Backend", "Personal"], store.GetAllTags([resource]));
        Assert.Equal(["backend", "Personal"], store.GetTags("api"));
        Assert.Equal(["backend", "Personal"], store.GetTagsByResource([])["api"]);
    }
 
    [Fact]
    public void AddTag_AddsTagsInOrderAndRaisesChanged()
    {
        var store = CreateStore();
        var changedCount = 0;
        store.Changed += () => changedCount++;
 
        Assert.True(store.AddTag("api", "backend"));
        Assert.True(store.AddTag("api", "core"));
        Assert.True(store.AddTag("worker", "backend"));
 
        Assert.Equal(["backend", "core"], store.GetTags("api"));
        Assert.Equal(["backend"], store.GetTags("worker"));
        Assert.Equal(["backend", "core"], store.GetAllTags());
        Assert.Equal(3, changedCount);
    }
 
    [Fact]
    public void AddTag_ReusesCasingOfExistingTag()
    {
        var store = CreateStore();
 
        Assert.True(store.AddTag("api", "Backend"));
        Assert.True(store.AddTag("worker", "  backend "));
        Assert.False(store.AddTag("api", "BACKEND"));
 
        Assert.Equal(["Backend"], store.GetTags("api"));
        Assert.Equal(["Backend"], store.GetTags("worker"));
        Assert.Equal(["Backend"], store.GetAllTags());
    }
 
    [Fact]
    public void AddTag_EmptyTagIsIgnored()
    {
        var store = CreateStore();
        var changedCount = 0;
        store.Changed += () => changedCount++;
 
        Assert.False(store.AddTag("api", "   "));
 
        Assert.Equal([], store.GetTags("api"));
        Assert.Equal(0, changedCount);
    }
 
    [Fact]
    public void RemoveTag_RemovesTagIgnoringCase()
    {
        var store = CreateStore();
        store.AddTag("api", "backend");
        store.AddTag("api", "core");
 
        Assert.True(store.RemoveTag("api", "BACKEND"));
        Assert.False(store.RemoveTag("api", "backend"));
        Assert.False(store.RemoveTag("worker", "core"));
 
        Assert.Equal(["core"], store.GetTags("api"));
        Assert.Equal(["core"], store.GetAllTags());
    }
 
    [Fact]
    public async Task Tags_PersistInBrowserLocalStorageAcrossStores()
    {
        var store = await CreateLoadedStoreAsync();
        store.AddTag("api", "backend");
        store.AddTag("api", "core");
        store.AddTag("worker", "backend");
        store.RemoveTag("api", "core");
 
        Assert.Equal("""{"api":["backend"],"worker":["backend"]}""", _browser.Items[s_storageKey]);
 
        // A new store reads the saved tags, as a new circuit does after a refresh or a restart.
        var reloadedStore = CreateStore();
        var changedCount = 0;
        reloadedStore.Changed += () => changedCount++;
        Assert.Empty(reloadedStore.GetTagsByResource());
 
        await reloadedStore.EnsureLoadedAsync().DefaultTimeout();
 
        var tagsByResource = reloadedStore.GetTagsByResource();
        Assert.Equal(["api", "worker"], tagsByResource.Keys.Order(StringComparer.Ordinal));
        Assert.Equal(["backend"], tagsByResource["api"]);
        Assert.Equal(["backend"], tagsByResource["worker"]);
        Assert.Equal(1, changedCount);
    }
 
    [Fact]
    public async Task Tags_AddedBeforeLoadAreMergedWithStoredTags()
    {
        var store = await CreateLoadedStoreAsync();
        store.AddTag("api", "backend");
 
        // Adding a tag before the stored tags are read must not replace them.
        var reloadedStore = CreateStore();
        reloadedStore.AddTag("api", "core");
        await reloadedStore.EnsureLoadedAsync().DefaultTimeout();
 
        Assert.Equal(["backend", "core"], reloadedStore.GetTags("api"));
        Assert.Equal(["backend", "core"], (await CreateLoadedStoreAsync()).GetTags("api"));
    }
 
    [Fact]
    public async Task Tags_ChangesFromAnotherTabAreKept()
    {
        var tabA = await CreateLoadedStoreAsync();
        var tabB = await CreateLoadedStoreAsync();
        tabA.AddTag("api", "backend");
        tabA.AddTag("cache", "data");
        var tabBChanges = 0;
        tabB.Changed += () => tabBChanges++;
 
        // Tab B didn't see tab A's tags. Its changes are applied to what tab A saved, including the existing casing.
        tabB.AddTag("worker", "BACKEND");
        tabB.RemoveTag("cache", "data");
 
        Assert.Equal("""{"api":["backend"],"worker":["backend"]}""", _browser.Items[s_storageKey]);
        Assert.Equal(["backend"], tabB.GetTags("api"));
        Assert.Equal(["backend"], tabB.GetTags("worker"));
        Assert.Equal(3, tabBChanges);
    }
 
    [Fact]
    public async Task Tags_OverlappingSavesFromTwoTabsKeepBothChanges()
    {
        var tabA = await CreateLoadedStoreAsync();
        var tabB = await CreateLoadedStoreAsync();
 
        // Tab A's save reads storage, and its response is held, so tab B saves while tab A's save is in progress.
        var releaseTabA = new TaskCompletionSource();
        _browser.OnAfterReadAsync = () => releaseTabA.Task;
        tabA.AddTag("api", "backend");
        _browser.OnAfterReadAsync = null;
        tabB.AddTag("worker", "db");
 
        // Tab B's save waits for tab A's, then reads what tab A saved instead of the value both tabs started from.
        Assert.False(_browser.Items.ContainsKey(s_storageKey));
        releaseTabA.SetResult();
        await _browser.WaitForItemAsync(s_storageKey, """{"api":["backend"],"worker":["db"]}""");
        await AsyncTestHelpers.AssertIsTrueRetryAsync(
            () => tabB.GetTags("api").SequenceEqual(["backend"]),
            "Tab B should adopt the saved tags.").DefaultTimeout();
    }
 
    [Fact]
    public async Task Tags_LoadThatReadBeforeASaveDoesNotReplaceIt()
    {
        var store = await CreateLoadedStoreAsync();
        store.AddTag("api", "backend");
 
        // The load reads storage, but its response is held until a save made after it has completed.
        var releaseLoad = new TaskCompletionSource();
        _browser.OnAfterReadAsync = () => releaseLoad.Task;
        var reloadedStore = CreateStore();
        var load = reloadedStore.EnsureLoadedAsync();
        _browser.OnAfterReadAsync = null;
 
        reloadedStore.AddTag("worker", "db");
        Assert.Equal("""{"api":["backend"],"worker":["db"]}""", _browser.Items[s_storageKey]);
 
        // The load's older value must not replace the saved one in memory.
        releaseLoad.SetResult();
        await load.DefaultTimeout();
        Assert.Equal(["db"], reloadedStore.GetTags("worker"));
        Assert.Equal(["backend"], reloadedStore.GetTags("api"));
    }
 
    [Fact]
    public async Task Tags_UnreadableStorageIsNotOverwritten()
    {
        var store = await CreateLoadedStoreAsync();
        store.AddTag("api", "backend");
 
        _browser.FailReads = true;
        var reloadedStore = CreateStore();
        await reloadedStore.EnsureLoadedAsync().DefaultTimeout();
        reloadedStore.AddTag("worker", "core");
 
        // The change is kept in memory, and the tags that couldn't be read aren't replaced.
        Assert.Equal(["core"], reloadedStore.GetTags("worker"));
        Assert.Equal("""{"api":["backend"]}""", _browser.Items[s_storageKey]);
 
        // Once storage can be read, loading again reads the stored tags, and the change is saved along with them.
        _browser.FailReads = false;
        await reloadedStore.EnsureLoadedAsync().DefaultTimeout();
        Assert.Equal(["backend"], reloadedStore.GetTags("api"));
        _timeProvider.Advance(TimeSpan.FromSeconds(1));
        await _browser.WaitForItemAsync(s_storageKey, """{"api":["backend"],"worker":["core"]}""");
    }
 
    [Fact]
    public async Task Tags_SaveIsRetriedAfterStorageIsUnavailable()
    {
        var store = await CreateLoadedStoreAsync();
        store.AddTag("api", "backend");
 
        // A brief disconnect while the only change is made: the change is saved once storage is back, with no other change.
        _browser.FailReads = true;
        store.AddTag("api", "core");
        Assert.Equal("""{"api":["backend"]}""", _browser.Items[s_storageKey]);
 
        _browser.FailReads = false;
        _timeProvider.Advance(TimeSpan.FromSeconds(1));
        await _browser.WaitForItemAsync(s_storageKey, """{"api":["backend","core"]}""");
    }
 
    [Fact]
    public async Task Tags_AreScopedToApplicationName()
    {
        var store = await CreateLoadedStoreAsync();
        store.AddTag("api", "backend");
 
        var otherApp = new ResourceTagStore(_browser.Storage, _locks, _timeProvider, Options.Create(new DashboardOptions { ApplicationName = "Other App" }), NullLogger<ResourceTagStore>.Instance);
        await otherApp.EnsureLoadedAsync().DefaultTimeout();
 
        Assert.Empty(otherApp.GetAllTags());
        Assert.Equal([s_storageKey], _browser.Items.Keys);
    }
 
    [Fact]
    public async Task Tags_MalformedStoredValueIsKeptAndReplaced()
    {
        // Not valid JSON, for example a value that was cut short, but still holding tags someone could recover.
        const string malformedValue = """{"api":["backend"]""";
        _browser.Items[s_storageKey] = malformedValue;
        var store = await CreateLoadedStoreAsync();
 
        store.AddTag("api", "core");
 
        Assert.Equal("""{"api":["core"]}""", _browser.Items[s_storageKey]);
        Assert.Equal(malformedValue, _browser.Items[$"{s_storageKey}_Unreadable"]);
    }
 
    [Fact]
    public async Task Tags_InvalidStoredValueIsKeptAndReplaced()
    {
        const string invalidValue = """{"api":"backend"}""";
        _browser.Items[s_storageKey] = invalidValue;
        var store = CreateStore();
 
        await store.EnsureLoadedAsync().DefaultTimeout();
        Assert.Empty(store.GetAllTags());
 
        // A value that can't be read never will be, so it's kept aside rather than preventing tags from being saved.
        store.AddTag("api", "core");
        Assert.Equal(["core"], store.GetTags("api"));
        Assert.Equal("""{"api":["core"]}""", _browser.Items[s_storageKey]);
        Assert.Equal(invalidValue, _browser.Items[$"{s_storageKey}_Unreadable"]);
    }
 
    [Theory]
    [InlineData(null, null)]
    [InlineData("   ", null)]
    [InlineData("backend", "backend")]
    [InlineData("  my   tag\t ", "my tag")]
    public void NormalizeTag_TrimsAndCollapsesWhitespace(string? tag, string? expected)
    {
        Assert.Equal(expected, ResourceTagStore.NormalizeTag(tag));
    }
 
    [Fact]
    public void NormalizeTag_TruncatesLongTags()
    {
        var normalized = ResourceTagStore.NormalizeTag(new string('a', ResourceTagStore.MaxTagLength + 10));
 
        Assert.Equal(new string('a', ResourceTagStore.MaxTagLength), normalized);
    }
 
    private ResourceTagStore CreateStore() =>
        new(_browser.Storage, _locks, _timeProvider, Options.Create(new DashboardOptions { ApplicationName = "TestApp" }), NullLogger<ResourceTagStore>.Instance);
 
    private async Task<ResourceTagStore> CreateLoadedStoreAsync()
    {
        var store = CreateStore();
        await store.EnsureLoadedAsync().DefaultTimeout();
        return store;
    }
}