Merge pull request #13884 from umbraco/v13/feature/extension-model

Add extension model for new backoffice

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/RuntimeAppCacheTests.cs

@@ -27,4 +27,25 @@ public abstract class RuntimeAppCacheTests : AppCacheTests
         Assert.AreEqual(default(DateTime), AppCache.GetCacheItem<DateTime>("DateTimeTest"));
         Assert.AreEqual(null, AppCache.GetCacheItem<DateTime?>("DateTimeTest"));
     }
+
+    [Test]
+    public async Task Can_Get_With_Async_Factory()
+    {
+        var value = await AppPolicyCache.GetCacheItemAsync("AsyncFactoryGetTest", async () => await GetValueAsync(5), TimeSpan.FromMilliseconds(100));
+        Assert.AreEqual(50, value);
+    }
+
+    [Test]
+    public async Task Can_Insert_With_Async_Factory()
+    {
+        await AppPolicyCache.InsertCacheItemAsync("AsyncFactoryInsertTest", async () => await GetValueAsync(10), TimeSpan.FromMilliseconds(100));
+        var value = AppPolicyCache.GetCacheItem<int>("AsyncFactoryInsertTest");
+        Assert.AreEqual(100, value);
+    }
+
+    private static async Task<int> GetValueAsync(int value)
+    {
+        await Task.Delay(10);
+        return value * 10;
+    }
 }

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Manifest/LegacyManifestContentAppTests.cs

@@ -14,7 +14,7 @@ using Umbraco.Cms.Tests.UnitTests.TestHelpers;
 namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Manifest;
 
 [TestFixture]
-public class ManifestContentAppTests
+public class LegacyManifestContentAppTests
 {
     [Test]
     public void Test()
@@ -70,11 +70,11 @@ public class ManifestContentAppTests
 
     private void AssertDefinition(object source, bool expected, string[] show, IReadOnlyUserGroup[] groups)
     {
-        var definition = JsonConvert.DeserializeObject<ManifestContentAppDefinition>("{" +
+        var definition = JsonConvert.DeserializeObject<LegacyManifestContentAppDefinition>("{" +
             (show.Length == 0
                 ? string.Empty
                 : " \"show\": [" + string.Join(",", show.Select(x => "\"" + x + "\"")) + "] ") + "}");
-        var factory = new ManifestContentAppFactory(definition, TestHelper.IOHelper);
+        var factory = new LegacyManifestContentAppFactory(definition, TestHelper.IOHelper);
         var app = factory.GetContentAppFor(source, groups);
         if (expected)
         {

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Manifest/LegacyManifestParserTests.cs

@@ -24,7 +24,7 @@ using Umbraco.Cms.Tests.UnitTests.TestHelpers;
 namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Manifest;
 
 [TestFixture]
-public class ManifestParserTests
+public class LegacyManifestParserTests
 {
     [SetUp]
     public void Setup()
@@ -37,21 +37,21 @@ public class ManifestParserTests
         };
         _ioHelper = TestHelper.IOHelper;
         var loggerFactory = NullLoggerFactory.Instance;
-        _parser = new ManifestParser(
+        _parser = new LegacyManifestParser(
             AppCaches.Disabled,
             new ManifestValueValidatorCollection(() => validators),
-            new ManifestFilterCollection(() => Enumerable.Empty<IManifestFilter>()),
-            loggerFactory.CreateLogger<ManifestParser>(),
+            new LegacyManifestFilterCollection(() => Enumerable.Empty<ILegacyManifestFilter>()),
+            loggerFactory.CreateLogger<LegacyManifestParser>(),
             _ioHelper,
             TestHelper.GetHostingEnvironment(),
             new JsonNetSerializer(),
             Mock.Of<ILocalizedTextService>(),
             Mock.Of<IShortStringHelper>(),
             Mock.Of<IDataValueEditorFactory>(),
-            Mock.Of<IManifestFileProviderFactory>());
+            Mock.Of<ILegacyPackageManifestFileProviderFactory>());
     }
 
-    private ManifestParser _parser;
+    private LegacyManifestParser _parser;
     private IIOHelper _ioHelper;
 
     [Test]
@@ -410,14 +410,14 @@ javascript: ['~/test.js',/*** some note about stuff asd09823-4**09234*/ '~/test2
         var manifest = _parser.ParseManifest(json);
         Assert.AreEqual(2, manifest.ContentApps.Length);
 
-        Assert.IsInstanceOf<ManifestContentAppDefinition>(manifest.ContentApps[0]);
+        Assert.IsInstanceOf<LegacyManifestContentAppDefinition>(manifest.ContentApps[0]);
         var app0 = manifest.ContentApps[0];
         Assert.AreEqual("myPackageApp1", app0.Alias);
         Assert.AreEqual("My App1", app0.Name);
         Assert.AreEqual("icon-foo", app0.Icon);
         Assert.AreEqual(_ioHelper.ResolveUrl("/App_Plugins/MyPackage/ContentApps/MyApp1.html"), app0.View);
 
-        Assert.IsInstanceOf<ManifestContentAppDefinition>(manifest.ContentApps[1]);
+        Assert.IsInstanceOf<LegacyManifestContentAppDefinition>(manifest.ContentApps[1]);
         var app1 = manifest.ContentApps[1];
         Assert.AreEqual("myPackageApp2", app1.Alias);
         Assert.AreEqual("My App2", app1.Name);
@@ -447,7 +447,7 @@ javascript: ['~/test.js',/*** some note about stuff asd09823-4**09234*/ '~/test2
         var manifest = _parser.ParseManifest(json);
         Assert.AreEqual(2, manifest.Dashboards.Length);
 
-        Assert.IsInstanceOf<ManifestDashboard>(manifest.Dashboards[0]);
+        Assert.IsInstanceOf<LegacyManifestDashboard>(manifest.Dashboards[0]);
         var db0 = manifest.Dashboards[0];
         Assert.AreEqual("something", db0.Alias);
         Assert.AreEqual(100, db0.Weight);
@@ -460,7 +460,7 @@ javascript: ['~/test.js',/*** some note about stuff asd09823-4**09234*/ '~/test2
         Assert.AreEqual(AccessRuleType.Deny, db0.AccessRules[1].Type);
         Assert.AreEqual("foo", db0.AccessRules[1].Value);
 
-        Assert.IsInstanceOf<ManifestDashboard>(manifest.Dashboards[1]);
+        Assert.IsInstanceOf<LegacyManifestDashboard>(manifest.Dashboards[1]);
         var db1 = manifest.Dashboards[1];
         Assert.AreEqual("something.else", db1.Alias);
         Assert.AreEqual(-1, db1.Weight);

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Manifest/PackageManifestReaderTests.cs

@@ -0,0 +1,244 @@
+using System.Text;
+using System.Text.Json;
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.IO;
+using Umbraco.Cms.Infrastructure.Manifest;
+using Umbraco.Cms.Infrastructure.Serialization;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Manifest;
+
+[TestFixture]
+public class PackageManifestReaderTests
+{
+    private IPackageManifestReader _reader;
+    private Mock<IDirectoryContents> _rootDirectoryContentsMock;
+    private Mock<ILogger<AppPluginsFileProviderPackageManifestReader>> _loggerMock;
+    private Mock<IFileProvider> _fileProviderMock;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _rootDirectoryContentsMock = new Mock<IDirectoryContents>();
+        _fileProviderMock = new Mock<IFileProvider>();
+        _fileProviderMock
+            .Setup(m => m.GetDirectoryContents(Constants.SystemDirectories.AppPlugins))
+            .Returns(_rootDirectoryContentsMock.Object);
+        var fileProviderFactoryMock = new Mock<IPackageManifestFileProviderFactory>();
+        fileProviderFactoryMock.Setup(m => m.Create()).Returns(_fileProviderMock.Object);
+
+        _loggerMock = new Mock<ILogger<AppPluginsFileProviderPackageManifestReader>>();
+        _reader = new AppPluginsFileProviderPackageManifestReader(fileProviderFactoryMock.Object, new SystemTextJsonSerializer(), _loggerMock.Object);
+    }
+
+    [Test]
+    public async Task Can_Read_PackageManifests_At_Root()
+    {
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(new List<IFileInfo> { CreatePackageManifestFile() }.GetEnumerator());
+
+        var result = await _reader.ReadPackageManifestsAsync();
+        Assert.AreEqual(1, result.Count());
+
+        var first = result.First();
+        Assert.AreEqual("My Package", first.Name);
+        Assert.AreEqual("1.2.3", first.Version);
+        Assert.AreEqual(2, first.Extensions.Count());
+        Assert.IsTrue(first.Extensions.All(e => e is JsonElement));
+    }
+
+    [Test]
+    public async Task Can_Read_PackageManifest_In_Root_Directories()
+    {
+        var directoryOne = CreateDirectoryMock("/my-extension", CreatePackageManifestFile(DefaultPackageManifestContent("Package One")));
+        var directoryTwo = CreateDirectoryMock("/my-other-extension", CreatePackageManifestFile(DefaultPackageManifestContent("Package Two")));
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(new List<IFileInfo> { directoryOne, directoryTwo }.GetEnumerator());
+
+        var result = await _reader.ReadPackageManifestsAsync();
+        Assert.AreEqual(2, result.Count());
+        Assert.AreEqual("Package One", result.First().Name);
+        Assert.AreEqual("Package Two", result.Last().Name);
+    }
+
+    [Test]
+    public async Task Can_Read_PackageManifests_Recursively()
+    {
+        var childFolder = CreateDirectoryMock("/my-parent-folder/my-child-folder", CreatePackageManifestFile(DefaultPackageManifestContent("Nested Package")));
+        var parentFolder = CreateDirectoryMock("/my-parent-folder", childFolder);
+
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(new List<IFileInfo> { parentFolder }.GetEnumerator());
+
+        var result = await _reader.ReadPackageManifestsAsync();
+        Assert.AreEqual(1, result.Count());
+        Assert.AreEqual("Nested Package", result.First().Name);
+    }
+
+    [Test]
+    public async Task Can_Skip_Empty_Directories()
+    {
+        var packageFolder = CreateDirectoryMock("/my-package-folder", CreatePackageManifestFile(DefaultPackageManifestContent("My Package")));
+        var emptyFolder = CreateDirectoryMock("/my-empty-folder");
+
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(new List<IFileInfo> { emptyFolder, packageFolder }.GetEnumerator());
+
+        var result = await _reader.ReadPackageManifestsAsync();
+        Assert.AreEqual(1, result.Count());
+        Assert.AreEqual("My Package", result.First().Name);
+    }
+
+    [Test]
+    public async Task Can_Skip_Other_Files()
+    {
+        var packageFolder = CreateDirectoryMock(
+            "/my-package-folder",
+            CreateOtherFile("my.js"),
+            CreatePackageManifestFile(DefaultPackageManifestContent("My Package")));
+        var otherFolder = CreateDirectoryMock(
+            "/my-empty-folder",
+            CreateOtherFile("some.js"),
+            CreateOtherFile("some.css"));
+
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(new List<IFileInfo> { otherFolder, packageFolder }.GetEnumerator());
+
+        var result = await _reader.ReadPackageManifestsAsync();
+        Assert.AreEqual(1, result.Count());
+        Assert.AreEqual("My Package", result.First().Name);
+    }
+
+    [Test]
+    public async Task Can_Handle_All_Empty_Directories()
+    {
+        var folders = Enumerable.Range(1, 10).Select(i => CreateDirectoryMock($"/my-empty-folder-{i}")).ToList();
+
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(folders.GetEnumerator());
+
+        var result = await _reader.ReadPackageManifestsAsync();
+        Assert.AreEqual(0, result.Count());
+    }
+
+    [Test]
+    public async Task Cannot_Read_PackageManifest_Without_Name()
+    {
+        var content = @"{
+    ""version"": ""1.2.3"",
+    ""allowTelemetry"": true,
+    ""extensions"": [{
+            ""type"": ""tree""
+        }, {
+            ""type"": ""headerApp""
+        }
+    ]
+}";
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(new List<IFileInfo> { CreatePackageManifestFile(content) }.GetEnumerator());
+
+        Assert.ThrowsAsync<JsonException>(() => _reader.ReadPackageManifestsAsync());
+        EnsureLogErrorWasCalled();
+    }
+
+    [Test]
+    public async Task Cannot_Read_PackageManifest_Without_Extensions()
+    {
+        var content = @"{
+    ""name"": ""Something"",
+    ""version"": ""1.2.3"",
+    ""allowTelemetry"": true
+}";
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(new List<IFileInfo> { CreatePackageManifestFile(content) }.GetEnumerator());
+
+        Assert.ThrowsAsync<JsonException>(() => _reader.ReadPackageManifestsAsync());
+        EnsureLogErrorWasCalled();
+    }
+
+    [TestCase("This is not JSON")]
+    [TestCase(@"{""name"": ""invalid-json"", ""version"": ")]
+    public async Task Cannot_Read_Invalid_PackageManifest(string content)
+    {
+        _rootDirectoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(new List<IFileInfo> { CreatePackageManifestFile(content) }.GetEnumerator());
+
+        Assert.ThrowsAsync<JsonException>(() => _reader.ReadPackageManifestsAsync());
+        EnsureLogErrorWasCalled();
+    }
+
+    private void EnsureLogErrorWasCalled(int numberOfTimes = 1) =>
+        _loggerMock.Verify(
+            x => x.Log(
+                It.Is<LogLevel>(l => l == LogLevel.Error),
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => true),
+                It.IsAny<Exception>(),
+                It.Is<Func<It.IsAnyType, Exception, string>>((v, t) => true)),
+            Times.Exactly(numberOfTimes));
+
+    private IFileInfo CreateDirectoryMock(string path, params IFileInfo[] children)
+    {
+        var directoryContentsMock = new Mock<IDirectoryContents>();
+        directoryContentsMock
+            .Setup(f => f.GetEnumerator())
+            .Returns(children.ToList().GetEnumerator());
+
+        _fileProviderMock
+            .Setup(m => m.GetDirectoryContents($"{Constants.SystemDirectories.AppPlugins}{path}"))
+            .Returns(directoryContentsMock.Object);
+
+        var fileInfo = new Mock<IFileInfo>();
+        fileInfo.SetupGet(f => f.IsDirectory).Returns(true);
+        fileInfo.SetupGet(f => f.Name).Returns(path.Split(Constants.CharArrays.ForwardSlash).Last());
+
+        return fileInfo.Object;
+    }
+
+    private IFileInfo CreatePackageManifestFile(string? content = null)
+    {
+        content ??= DefaultPackageManifestContent();
+
+        var fileInfo = new Mock<IFileInfo>();
+        fileInfo.SetupGet(f => f.IsDirectory).Returns(false);
+        fileInfo.SetupGet(f => f.Name).Returns("umbraco-package.json");
+        fileInfo.Setup(f => f.CreateReadStream()).Returns(new MemoryStream(Encoding.UTF8.GetBytes(content)));
+
+        return fileInfo.Object;
+    }
+
+    private IFileInfo CreateOtherFile(string name)
+    {
+        var fileInfo = new Mock<IFileInfo>();
+        fileInfo.SetupGet(f => f.IsDirectory).Returns(false);
+        fileInfo.SetupGet(f => f.Name).Returns(name);
+        fileInfo.Setup(f => f.CreateReadStream()).Returns(new MemoryStream(Encoding.UTF8.GetBytes("this is some file content")));
+
+        return fileInfo.Object;
+    }
+
+    private static string DefaultPackageManifestContent(string name = "My Package")
+        => @"{
+    ""name"": ""##NAME##"",
+    ""version"": ""1.2.3"",
+    ""allowTelemetry"": true,
+    ""extensions"": [{
+            ""type"": ""tree""
+        }, {
+            ""type"": ""headerApp""
+        }
+    ]
+}".Replace("##NAME##", name);
+}

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Manifest/PackageManifestServiceTests.cs

@@ -0,0 +1,69 @@
+using Microsoft.Extensions.Options;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.Manifest;
+using Umbraco.Cms.Infrastructure.Manifest;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Manifest;
+
+[TestFixture]
+public class PackageManifestServiceTests
+{
+    private IPackageManifestService _service;
+    private Mock<IPackageManifestReader> _readerMock;
+    private IAppPolicyCache _runtimeCache;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _readerMock = new Mock<IPackageManifestReader>();
+        _readerMock.Setup(r => r.ReadPackageManifestsAsync()).ReturnsAsync(
+            new[]
+            {
+                new PackageManifest { Name = "Test", Extensions = Array.Empty<object>() }
+            });
+
+        _runtimeCache = new ObjectCacheAppCache();
+        AppCaches appCaches = new AppCaches(
+                _runtimeCache,
+                NoAppCache.Instance,
+                new IsolatedCaches(type => NoAppCache.Instance));
+
+        _service = new PackageManifestService(new[] { _readerMock.Object }, appCaches, new OptionsWrapper<PackageManifestSettings>(new PackageManifestSettings()));
+    }
+
+    [Test]
+    public async Task Caches_PackageManifests()
+    {
+        var result = await _service.GetPackageManifestsAsync();
+        Assert.AreEqual(1, result.Count());
+
+        var result2 = await _service.GetPackageManifestsAsync();
+        Assert.AreEqual(1, result2.Count());
+
+        var result3 = await _service.GetPackageManifestsAsync();
+        Assert.AreEqual(1, result3.Count());
+
+        _readerMock.Verify(r => r.ReadPackageManifestsAsync(), Times.Exactly(1));
+    }
+
+    [Test]
+    public async Task Reloads_PackageManifest_After_Cache_Clear()
+    {
+        var result = await _service.GetPackageManifestsAsync();
+        Assert.AreEqual(1, result.Count());
+        _runtimeCache.Clear();
+
+        var result2 = await _service.GetPackageManifestsAsync();
+        Assert.AreEqual(1, result2.Count());
+        _runtimeCache.Clear();
+
+        var result3 = await _service.GetPackageManifestsAsync();
+        Assert.AreEqual(1, result3.Count());
+        _runtimeCache.Clear();
+
+        _readerMock.Verify(r => r.ReadPackageManifestsAsync(), Times.Exactly(3));
+    }
+}

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/TelemetryServiceTests.cs

@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Cms.Core.Configuration;
@@ -16,62 +13,60 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry;
 public class TelemetryServiceTests
 {
     [Test]
-    public void UsesGetOrCreateSiteId()
+    public async Task UsesGetOrCreateSiteId()
     {
         var version = CreateUmbracoVersion(9, 3, 1);
         var siteIdentifierServiceMock = new Mock<ISiteIdentifierService>();
         var usageInformationServiceMock = new Mock<IUsageInformationService>();
         var sut = new TelemetryService(
-            Mock.Of<IManifestParser>(),
             version,
             siteIdentifierServiceMock.Object,
             usageInformationServiceMock.Object,
-            Mock.Of<IMetricsConsentService>());
+            Mock.Of<IMetricsConsentService>(),
+            Mock.Of<IPackageManifestService>());
         Guid guid;
 
-        sut.TryGetTelemetryReportData(out _);
+        await sut.GetTelemetryReportDataAsync();
         siteIdentifierServiceMock.Verify(x => x.TryGetOrCreateSiteIdentifier(out guid), Times.Once);
     }
 
     [Test]
-    public void SkipsIfCantGetOrCreateId()
+    public async Task SkipsIfCantGetOrCreateId()
     {
         var version = CreateUmbracoVersion(9, 3, 1);
         var sut = new TelemetryService(
-            Mock.Of<IManifestParser>(),
             version,
             CreateSiteIdentifierService(false),
             Mock.Of<IUsageInformationService>(),
-            Mock.Of<IMetricsConsentService>());
+            Mock.Of<IMetricsConsentService>(),
+            Mock.Of<IPackageManifestService>());
 
-        var result = sut.TryGetTelemetryReportData(out var telemetry);
-
-        Assert.IsFalse(result);
-        Assert.IsNull(telemetry);
+        var result = await sut.GetTelemetryReportDataAsync();
+        Assert.IsNull(result);
     }
 
     [Test]
-    public void ReturnsSemanticVersionWithoutBuild()
+    public async Task ReturnsSemanticVersionWithoutBuild()
     {
         var version = CreateUmbracoVersion(9, 1, 1, "-rc", "-ad2f4k2d");
 
         var metricsConsentService = new Mock<IMetricsConsentService>();
         metricsConsentService.Setup(x => x.GetConsentLevel()).Returns(TelemetryLevel.Detailed);
         var sut = new TelemetryService(
-            Mock.Of<IManifestParser>(),
             version,
             CreateSiteIdentifierService(),
             Mock.Of<IUsageInformationService>(),
-            metricsConsentService.Object);
+            metricsConsentService.Object,
+            Mock.Of<IPackageManifestService>());
 
-        var result = sut.TryGetTelemetryReportData(out var telemetry);
+        var result = await sut.GetTelemetryReportDataAsync();
 
-        Assert.IsTrue(result);
-        Assert.AreEqual("9.1.1-rc", telemetry.Version);
+        Assert.IsNotNull(result);
+        Assert.AreEqual("9.1.1-rc", result.Version);
     }
 
     [Test]
-    public void CanGatherPackageTelemetry()
+    public async Task CanGatherPackageTelemetry()
     {
         var version = CreateUmbracoVersion(9, 1, 1);
         var versionPackageName = "VersionPackage";
@@ -79,69 +74,69 @@ public class TelemetryServiceTests
         var noVersionPackageName = "NoVersionPackage";
         PackageManifest[] manifests =
         {
-            new() { PackageName = versionPackageName, Version = packageVersion },
-            new() { PackageName = noVersionPackageName },
+            new() { Name = versionPackageName, Version = packageVersion, Extensions = Array.Empty<object>()},
+            new() { Name = noVersionPackageName, Extensions = Array.Empty<object>() },
         };
-        var manifestParser = CreateManifestParser(manifests);
+        var packageManifestService = CreatePackageManifestService(manifests);
         var metricsConsentService = new Mock<IMetricsConsentService>();
         metricsConsentService.Setup(x => x.GetConsentLevel()).Returns(TelemetryLevel.Basic);
         var sut = new TelemetryService(
-            manifestParser,
             version,
             CreateSiteIdentifierService(),
             Mock.Of<IUsageInformationService>(),
-            metricsConsentService.Object);
+            metricsConsentService.Object,
+            packageManifestService);
 
-        var success = sut.TryGetTelemetryReportData(out var telemetry);
+        var result = await sut.GetTelemetryReportDataAsync();
 
-        Assert.IsTrue(success);
+        Assert.IsNotNull(result);
         Assert.Multiple(() =>
         {
-            Assert.AreEqual(2, telemetry.Packages.Count());
-            var versionPackage = telemetry.Packages.FirstOrDefault(x => x.Name == versionPackageName);
+            Assert.AreEqual(2, result.Packages.Count());
+            var versionPackage = result.Packages.FirstOrDefault(x => x.Name == versionPackageName);
             Assert.AreEqual(versionPackageName, versionPackage.Name);
             Assert.AreEqual(packageVersion, versionPackage.Version);
 
-            var noVersionPackage = telemetry.Packages.FirstOrDefault(x => x.Name == noVersionPackageName);
+            var noVersionPackage = result.Packages.FirstOrDefault(x => x.Name == noVersionPackageName);
             Assert.AreEqual(noVersionPackageName, noVersionPackage.Name);
             Assert.AreEqual(string.Empty, noVersionPackage.Version);
         });
     }
 
     [Test]
-    public void RespectsAllowPackageTelemetry()
+    public async Task RespectsAllowPackageTelemetry()
     {
         var version = CreateUmbracoVersion(9, 1, 1);
         PackageManifest[] manifests =
         {
-            new() { PackageName = "DoNotTrack", AllowPackageTelemetry = false },
-            new() { PackageName = "TrackingAllowed", AllowPackageTelemetry = true },
+            new() { Name = "DoNotTrack", AllowTelemetry = false, Extensions = Array.Empty<object>() },
+            new() { Name = "TrackingAllowed", AllowTelemetry = true, Extensions = Array.Empty<object>() },
         };
-        var manifestParser = CreateManifestParser(manifests);
+        var packageManifestService = CreatePackageManifestService(manifests);
         var metricsConsentService = new Mock<IMetricsConsentService>();
         metricsConsentService.Setup(x => x.GetConsentLevel()).Returns(TelemetryLevel.Basic);
         var sut = new TelemetryService(
-            manifestParser,
             version,
             CreateSiteIdentifierService(),
             Mock.Of<IUsageInformationService>(),
-            metricsConsentService.Object);
+            metricsConsentService.Object,
+            packageManifestService);
 
-        var success = sut.TryGetTelemetryReportData(out var telemetry);
+        var result = await sut.GetTelemetryReportDataAsync();
 
-        Assert.IsTrue(success);
+        Assert.IsNotNull(result);
         Assert.Multiple(() =>
         {
-            Assert.AreEqual(1, telemetry.Packages.Count());
-            Assert.AreEqual("TrackingAllowed", telemetry.Packages.First().Name);
+            Assert.AreEqual(1, result.Packages.Count());
+            Assert.AreEqual("TrackingAllowed", result.Packages.First().Name);
         });
     }
 
-    private IManifestParser CreateManifestParser(IEnumerable<PackageManifest> manifests)
+    private IPackageManifestService CreatePackageManifestService(IEnumerable<PackageManifest> manifests)
     {
-        var manifestParserMock = new Mock<IManifestParser>();
-        manifestParserMock.Setup(x => x.GetManifests()).Returns(manifests);
-        return manifestParserMock.Object;
+        var mock = new Mock<IPackageManifestService>();
+        mock.Setup(x => x.GetPackageManifestsAsync()).Returns(Task.FromResult(manifests));
+        return mock.Object;
     }
 
     private IUmbracoVersion CreateUmbracoVersion(int major, int minor, int patch, string prerelease = "", string build = "")