From 0c7ef060314440ef3d59e5e7f7bb1f5fd3b62be2 Mon Sep 17 00:00:00 2001 From: Mole Date: Mon, 28 Feb 2022 13:59:39 +0100 Subject: [PATCH] V9: Fix missing site identifier (#12040) * Add SiteIdentifierService * Use SiteIdentifierService in TelemetryService * Use SiteIdentifierService when installing * Remove timeout * Use TryGetOrCreateSiteIdentifier in TelemetryService * Add site identifier to dashboard url * Fix and add tests * Don't accept empty guid as valid site identifier * Fix dashboard controller * Fix site id query parameter * Use Optionsmonitor onchange Co-authored-by: nikolajlauridsen Co-authored-by: Bjarke Berg --- .../DependencyInjection/UmbracoBuilder.cs | 1 + .../InstallSteps/TelemetryIdentifierStep.cs | 35 ++++---- .../Telemetry/ISiteIdentifierService.cs | 31 +++++++ .../Telemetry/SiteIdentifierService.cs | 81 +++++++++++++++++++ .../Telemetry/TelemetryService.cs | 32 ++------ .../UmbracoBuilder.Installer.cs | 10 ++- .../HostedServices/ReportSiteTask.cs | 3 - .../Controllers/DashboardController.cs | 38 ++++++++- .../Telemetry/SiteIdentifierServiceTests.cs | 77 ++++++++++++++++++ .../Telemetry/TelemetryServiceTests.cs | 59 +++++++------- 10 files changed, 287 insertions(+), 80 deletions(-) create mode 100644 src/Umbraco.Core/Telemetry/ISiteIdentifierService.cs create mode 100644 src/Umbraco.Core/Telemetry/SiteIdentifierService.cs create mode 100644 tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/SiteIdentifierServiceTests.cs diff --git a/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs b/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs index c4a95d45e5..235dc71252 100644 --- a/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs +++ b/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs @@ -262,6 +262,7 @@ namespace Umbraco.Cms.Core.DependencyInjection Services.AddSingleton(); // Register telemetry service used to gather data about installed packages + Services.AddUnique(); Services.AddUnique(); // Register a noop IHtmlSanitizer to be replaced diff --git a/src/Umbraco.Core/Install/InstallSteps/TelemetryIdentifierStep.cs b/src/Umbraco.Core/Install/InstallSteps/TelemetryIdentifierStep.cs index 37769afc53..d95fa6919d 100644 --- a/src/Umbraco.Core/Install/InstallSteps/TelemetryIdentifierStep.cs +++ b/src/Umbraco.Core/Install/InstallSteps/TelemetryIdentifierStep.cs @@ -1,10 +1,13 @@ using System; using System.Threading.Tasks; +using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; using Umbraco.Cms.Core.Configuration; using Umbraco.Cms.Core.Configuration.Models; using Umbraco.Cms.Core.Install.Models; +using Umbraco.Cms.Core.Telemetry; +using Umbraco.Cms.Web.Common.DependencyInjection; namespace Umbraco.Cms.Core.Install.InstallSteps { @@ -13,31 +16,29 @@ namespace Umbraco.Cms.Core.Install.InstallSteps PerformsAppRestart = false)] public class TelemetryIdentifierStep : InstallSetupStep { - private readonly ILogger _logger; private readonly IOptions _globalSettings; - private readonly IConfigManipulator _configManipulator; + private readonly ISiteIdentifierService _siteIdentifierService; - public TelemetryIdentifierStep(ILogger logger, IOptions globalSettings, IConfigManipulator configManipulator) + public TelemetryIdentifierStep( + IOptions globalSettings, + ISiteIdentifierService siteIdentifierService) { - _logger = logger; _globalSettings = globalSettings; - _configManipulator = configManipulator; + _siteIdentifierService = siteIdentifierService; + } + + [Obsolete("Use constructor that takes GlobalSettings and ISiteIdentifierService")] + public TelemetryIdentifierStep( + ILogger logger, + IOptions globalSettings, + IConfigManipulator configManipulator) + : this(globalSettings, StaticServiceProvider.Instance.GetRequiredService()) + { } public override Task ExecuteAsync(object model) { - // Generate GUID - var telemetrySiteIdentifier = Guid.NewGuid(); - - try - { - _configManipulator.SetGlobalId(telemetrySiteIdentifier.ToString()); - } - catch (Exception ex) - { - _logger.LogError(ex, "Couldn't update config files with a telemetry site identifier"); - } - + _siteIdentifierService.TryCreateSiteIdentifier(out _); return Task.FromResult(null); } diff --git a/src/Umbraco.Core/Telemetry/ISiteIdentifierService.cs b/src/Umbraco.Core/Telemetry/ISiteIdentifierService.cs new file mode 100644 index 0000000000..7fd0ee5a85 --- /dev/null +++ b/src/Umbraco.Core/Telemetry/ISiteIdentifierService.cs @@ -0,0 +1,31 @@ +using System; + +namespace Umbraco.Cms.Core.Telemetry +{ + /// + /// Used to get and create the site identifier + /// + public interface ISiteIdentifierService + { + + /// + /// Tries to get the site identifier + /// + /// True if success. + bool TryGetSiteIdentifier(out Guid siteIdentifier); + + /// + /// Creates the site identifier and writes it to config. + /// + /// asd. + /// True if success. + bool TryCreateSiteIdentifier(out Guid createdGuid); + + /// + /// Tries to get the site identifier or otherwise create it if it doesn't exist. + /// + /// The out parameter for the existing or create site identifier. + /// True if success. + bool TryGetOrCreateSiteIdentifier(out Guid siteIdentifier); + } +} diff --git a/src/Umbraco.Core/Telemetry/SiteIdentifierService.cs b/src/Umbraco.Core/Telemetry/SiteIdentifierService.cs new file mode 100644 index 0000000000..b6e40665c1 --- /dev/null +++ b/src/Umbraco.Core/Telemetry/SiteIdentifierService.cs @@ -0,0 +1,81 @@ +using System; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; +using Umbraco.Cms.Core.Configuration; +using Umbraco.Cms.Core.Configuration.Models; + +namespace Umbraco.Cms.Core.Telemetry +{ + /// + internal class SiteIdentifierService : ISiteIdentifierService + { + private GlobalSettings _globalSettings; + private readonly IConfigManipulator _configManipulator; + private readonly ILogger _logger; + + public SiteIdentifierService( + IOptionsMonitor optionsMonitor, + IConfigManipulator configManipulator, + ILogger logger) + { + _globalSettings = optionsMonitor.CurrentValue; + optionsMonitor.OnChange(globalSettings => _globalSettings = globalSettings); + _configManipulator = configManipulator; + _logger = logger; + } + + /// + public bool TryGetSiteIdentifier(out Guid siteIdentifier) + { + // Parse telemetry string as a GUID & verify its a GUID and not some random string + // since users may have messed with or decided to empty the app setting or put in something random + if (Guid.TryParse(_globalSettings.Id, out var parsedTelemetryId) is false + || parsedTelemetryId == Guid.Empty) + { + siteIdentifier = Guid.Empty; + return false; + } + + siteIdentifier = parsedTelemetryId; + return true; + } + + /// + public bool TryGetOrCreateSiteIdentifier(out Guid siteIdentifier) + { + if (TryGetSiteIdentifier(out Guid existingId)) + { + siteIdentifier = existingId; + return true; + } + + if (TryCreateSiteIdentifier(out Guid createdId)) + { + siteIdentifier = createdId; + return true; + } + + siteIdentifier = Guid.Empty; + return false; + } + + /// + public bool TryCreateSiteIdentifier(out Guid createdGuid) + { + createdGuid = Guid.NewGuid(); + + try + { + _configManipulator.SetGlobalId(createdGuid.ToString()); + } + catch (Exception ex) + { + _logger.LogError(ex, "Couldn't update config files with a telemetry site identifier"); + createdGuid = Guid.Empty; + return false; + } + + return true; + } + } +} diff --git a/src/Umbraco.Core/Telemetry/TelemetryService.cs b/src/Umbraco.Core/Telemetry/TelemetryService.cs index 63e4e1ff49..d5a3acac98 100644 --- a/src/Umbraco.Core/Telemetry/TelemetryService.cs +++ b/src/Umbraco.Core/Telemetry/TelemetryService.cs @@ -1,8 +1,6 @@ using System; using System.Collections.Generic; -using Microsoft.Extensions.Options; using Umbraco.Cms.Core.Configuration; -using Umbraco.Cms.Core.Configuration.Models; using Umbraco.Cms.Core.Manifest; using Umbraco.Cms.Core.Telemetry.Models; using Umbraco.Extensions; @@ -12,27 +10,27 @@ namespace Umbraco.Cms.Core.Telemetry /// internal class TelemetryService : ITelemetryService { - private readonly IOptionsMonitor _globalSettings; private readonly IManifestParser _manifestParser; private readonly IUmbracoVersion _umbracoVersion; + private readonly ISiteIdentifierService _siteIdentifierService; /// /// Initializes a new instance of the class. /// public TelemetryService( - IOptionsMonitor globalSettings, IManifestParser manifestParser, - IUmbracoVersion umbracoVersion) + IUmbracoVersion umbracoVersion, + ISiteIdentifierService siteIdentifierService) { _manifestParser = manifestParser; _umbracoVersion = umbracoVersion; - _globalSettings = globalSettings; + _siteIdentifierService = siteIdentifierService; } /// public bool TryGetTelemetryReportData(out TelemetryReportData telemetryReportData) { - if (TryGetTelemetryId(out Guid telemetryId) is false) + if (_siteIdentifierService.TryGetOrCreateSiteIdentifier(out Guid telemetryId) is false) { telemetryReportData = null; return false; @@ -42,28 +40,14 @@ namespace Umbraco.Cms.Core.Telemetry { Id = telemetryId, Version = _umbracoVersion.SemanticVersion.ToSemanticStringWithoutBuild(), - Packages = GetPackageTelemetry() + Packages = GetPackageTelemetry(), }; return true; } - private bool TryGetTelemetryId(out Guid telemetryId) - { - // Parse telemetry string as a GUID & verify its a GUID and not some random string - // since users may have messed with or decided to empty the app setting or put in something random - if (Guid.TryParse(_globalSettings.CurrentValue.Id, out var parsedTelemetryId) is false) - { - telemetryId = Guid.Empty; - return false; - } - - telemetryId = parsedTelemetryId; - return true; - } - private IEnumerable GetPackageTelemetry() { - List packages = new (); + List packages = new(); IEnumerable manifests = _manifestParser.GetManifests(); foreach (PackageManifest manifest in manifests) @@ -76,7 +60,7 @@ namespace Umbraco.Cms.Core.Telemetry packages.Add(new PackageTelemetry { Name = manifest.PackageName, - Version = manifest.Version ?? string.Empty + Version = manifest.Version ?? string.Empty, }); } diff --git a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Installer.cs b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Installer.cs index e0958bfdb7..d750eb15e0 100644 --- a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Installer.cs +++ b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Installer.cs @@ -1,7 +1,10 @@ using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using Umbraco.Cms.Core.Configuration.Models; using Umbraco.Cms.Core.DependencyInjection; using Umbraco.Cms.Core.Install.InstallSteps; using Umbraco.Cms.Core.Install.Models; +using Umbraco.Cms.Core.Telemetry; using Umbraco.Cms.Infrastructure.Install; using Umbraco.Cms.Infrastructure.Install.InstallSteps; using Umbraco.Extensions; @@ -19,7 +22,12 @@ namespace Umbraco.Cms.Infrastructure.DependencyInjection builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); - builder.Services.AddScoped(); + builder.Services.AddScoped(provider => + { + return new TelemetryIdentifierStep( + provider.GetRequiredService>(), + provider.GetRequiredService()); + }); builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); diff --git a/src/Umbraco.Infrastructure/HostedServices/ReportSiteTask.cs b/src/Umbraco.Infrastructure/HostedServices/ReportSiteTask.cs index 7591290bf4..cfce96281c 100644 --- a/src/Umbraco.Infrastructure/HostedServices/ReportSiteTask.cs +++ b/src/Umbraco.Infrastructure/HostedServices/ReportSiteTask.cs @@ -59,9 +59,6 @@ namespace Umbraco.Cms.Infrastructure.HostedServices // Send data to LIVE telemetry s_httpClient.BaseAddress = new Uri("https://telemetry.umbraco.com/"); - // Set a low timeout - no need to use a larger default timeout for this POST request - s_httpClient.Timeout = new TimeSpan(0, 0, 1); - #if DEBUG // Send data to DEBUG telemetry service s_httpClient.BaseAddress = new Uri("https://telemetry.rainbowsrock.net/"); diff --git a/src/Umbraco.Web.BackOffice/Controllers/DashboardController.cs b/src/Umbraco.Web.BackOffice/Controllers/DashboardController.cs index 955081fa73..342686ceb3 100644 --- a/src/Umbraco.Web.BackOffice/Controllers/DashboardController.cs +++ b/src/Umbraco.Web.BackOffice/Controllers/DashboardController.cs @@ -7,6 +7,7 @@ using System.Text; using System.Threading.Tasks; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; +using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; using Newtonsoft.Json; @@ -19,10 +20,12 @@ using Umbraco.Cms.Core.Models.ContentEditing; using Umbraco.Cms.Core.Security; using Umbraco.Cms.Core.Services; using Umbraco.Cms.Core.Strings; +using Umbraco.Cms.Core.Telemetry; using Umbraco.Cms.Web.BackOffice.Filters; using Umbraco.Cms.Web.Common.Attributes; using Umbraco.Cms.Web.Common.Authorization; using Umbraco.Cms.Web.Common.Controllers; +using Umbraco.Cms.Web.Common.DependencyInjection; using Umbraco.Cms.Web.Common.Filters; using Umbraco.Extensions; using Constants = Umbraco.Cms.Core.Constants; @@ -43,10 +46,13 @@ namespace Umbraco.Cms.Web.BackOffice.Controllers private readonly IDashboardService _dashboardService; private readonly IUmbracoVersion _umbracoVersion; private readonly IShortStringHelper _shortStringHelper; + private readonly ISiteIdentifierService _siteIdentifierService; private readonly ContentDashboardSettings _dashboardSettings; + /// /// Initializes a new instance of the with all its dependencies. /// + [ActivatorUtilitiesConstructor] public DashboardController( IBackOfficeSecurityAccessor backOfficeSecurityAccessor, AppCaches appCaches, @@ -54,7 +60,8 @@ namespace Umbraco.Cms.Web.BackOffice.Controllers IDashboardService dashboardService, IUmbracoVersion umbracoVersion, IShortStringHelper shortStringHelper, - IOptions dashboardSettings) + IOptions dashboardSettings, + ISiteIdentifierService siteIdentifierService) { _backOfficeSecurityAccessor = backOfficeSecurityAccessor; @@ -63,9 +70,32 @@ namespace Umbraco.Cms.Web.BackOffice.Controllers _dashboardService = dashboardService; _umbracoVersion = umbracoVersion; _shortStringHelper = shortStringHelper; + _siteIdentifierService = siteIdentifierService; _dashboardSettings = dashboardSettings.Value; } + + [Obsolete("Use the constructor that accepts ISiteIdentifierService")] + public DashboardController( + IBackOfficeSecurityAccessor backOfficeSecurityAccessor, + AppCaches appCaches, + ILogger logger, + IDashboardService dashboardService, + IUmbracoVersion umbracoVersion, + IShortStringHelper shortStringHelper, + IOptions dashboardSettings) + : this( + backOfficeSecurityAccessor, + appCaches, + logger, + dashboardService, + umbracoVersion, + shortStringHelper, + dashboardSettings, + StaticServiceProvider.Instance.GetRequiredService()) + { + } + //we have just one instance of HttpClient shared for the entire application private static readonly HttpClient HttpClient = new HttpClient(); @@ -79,6 +109,7 @@ namespace Umbraco.Cms.Web.BackOffice.Controllers var language = user.Language; var version = _umbracoVersion.SemanticVersion.ToSemanticStringWithoutBuild(); var isAdmin = user.IsAdmin(); + _siteIdentifierService.TryGetOrCreateSiteIdentifier(out Guid siteIdentifier); if (!IsAllowedUrl(baseUrl)) { @@ -90,14 +121,15 @@ namespace Umbraco.Cms.Web.BackOffice.Controllers return JObject.Parse(errorJson); } - var url = string.Format("{0}{1}?section={2}&allowed={3}&lang={4}&version={5}&admin={6}", + var url = string.Format("{0}{1}?section={2}&allowed={3}&lang={4}&version={5}&admin={6}&siteid={7}", baseUrl, _dashboardSettings.ContentDashboardPath, section, allowedSections, language, version, - isAdmin); + isAdmin, + siteIdentifier); var key = "umbraco-dynamic-dashboard-" + language + allowedSections.Replace(",", "-") + section; var content = _appCaches.RuntimeCache.GetCacheItem(key); diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/SiteIdentifierServiceTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/SiteIdentifierServiceTests.cs new file mode 100644 index 0000000000..81934cc1be --- /dev/null +++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/SiteIdentifierServiceTests.cs @@ -0,0 +1,77 @@ +using System; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; +using Moq; +using NUnit.Framework; +using Umbraco.Cms.Core.Configuration; +using Umbraco.Cms.Core.Configuration.Models; +using Umbraco.Cms.Core.Telemetry; + +namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry +{ + [TestFixture] + public class SiteIdentifierServiceTests + { + [TestCase("0F1785C5-7BA0-4C52-AB62-863BD2C8F3FE", true)] + [TestCase("This is not a guid", false)] + [TestCase("", false)] + [TestCase("00000000-0000-0000-0000-000000000000", false)] // Don't count empty GUID as valid + public void TryGetOnlyPassesIfValidId(string guidString, bool shouldSucceed) + { + var globalSettings = CreateGlobalSettings(guidString); + var sut = new SiteIdentifierService( + globalSettings, + Mock.Of(), + Mock.Of>()); + + var result = sut.TryGetSiteIdentifier(out var siteIdentifier); + + Assert.AreEqual(shouldSucceed, result); + if (shouldSucceed) + { + // When toString is called on a GUID it will to lower, so do the same to our guidString + Assert.AreEqual(guidString.ToLower(), siteIdentifier.ToString()); + } + else + { + Assert.AreEqual(Guid.Empty, siteIdentifier); + } + } + + [TestCase("0F1785C5-7BA0-4C52-AB62-863BD2C8F3FE", false)] + [TestCase("This is not a guid", true)] + [TestCase("", true)] + [TestCase("00000000-0000-0000-0000-000000000000", true)] // Don't count empty GUID as valid + public void TryGetOrCreateOnlyCreatesNewGuidIfCurrentIsMissingOrInvalid(string guidString, bool shouldCreate) + { + var globalSettings = CreateGlobalSettings(guidString); + var configManipulatorMock = new Mock(); + + var sut = new SiteIdentifierService( + globalSettings, + configManipulatorMock.Object, + Mock.Of>()); + + var result = sut.TryGetOrCreateSiteIdentifier(out var identifier); + + if (shouldCreate) + { + configManipulatorMock.Verify(x => x.SetGlobalId(It.IsAny()), Times.Once); + Assert.AreNotEqual(Guid.Empty, identifier); + Assert.IsTrue(result); + } + else + { + configManipulatorMock.Verify(x => x.SetGlobalId(It.IsAny()), Times.Never()); + Assert.AreEqual(guidString.ToLower(), identifier.ToString()); + Assert.IsTrue(result); + } + } + + private IOptionsMonitor CreateGlobalSettings(string guidString) + { + var globalSettings = new GlobalSettings { Id = guidString }; + return Mock.Of>(x => x.CurrentValue == globalSettings); + } + } +} diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/TelemetryServiceTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/TelemetryServiceTests.cs index 1c92569695..910ca7c792 100644 --- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/TelemetryServiceTests.cs +++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/TelemetryServiceTests.cs @@ -15,36 +15,36 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry [TestFixture] public class TelemetryServiceTests { - [TestCase("0F1785C5-7BA0-4C52-AB62-863BD2C8F3FE", true)] - [TestCase("This is not a guid", false)] - [TestCase("", false)] - public void OnlyParsesIfValidId(string guidString, bool shouldSucceed) + [Test] + public void UsesGetOrCreateSiteId() { - var globalSettings = CreateGlobalSettings(guidString); - var version = CreateUmbracoVersion(9, 1, 1); - var sut = new TelemetryService(globalSettings, Mock.Of(), version); + var version = CreateUmbracoVersion(9, 3, 1); + var siteIdentifierServiceMock = new Mock(); + var sut = new TelemetryService(Mock.Of(), version, siteIdentifierServiceMock.Object); + Guid guid; + + var result = sut.TryGetTelemetryReportData(out var telemetryReportData); + siteIdentifierServiceMock.Verify(x => x.TryGetOrCreateSiteIdentifier(out guid), Times.Once); + } + + [Test] + public void SkipsIfCantGetOrCreateId() + { + var version = CreateUmbracoVersion(9, 3, 1); + var sut = new TelemetryService(Mock.Of(), version, createSiteIdentifierService(false)); var result = sut.TryGetTelemetryReportData(out var telemetry); - Assert.AreEqual(shouldSucceed, result); - if (shouldSucceed) - { - // When toString is called on a GUID it will to lower, so do the same to our guidString - Assert.AreEqual(guidString.ToLower(), telemetry.Id.ToString()); - } - else - { - Assert.IsNull(telemetry); - } + Assert.IsFalse(result); + Assert.IsNull(telemetry); } [Test] public void ReturnsSemanticVersionWithoutBuild() { - var globalSettings = CreateGlobalSettings(); var version = CreateUmbracoVersion(9, 1, 1, "-rc", "-ad2f4k2d"); - var sut = new TelemetryService(globalSettings, Mock.Of(), version); + var sut = new TelemetryService(Mock.Of(), version, createSiteIdentifierService()); var result = sut.TryGetTelemetryReportData(out var telemetry); @@ -55,7 +55,6 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry [Test] public void CanGatherPackageTelemetry() { - var globalSettings = CreateGlobalSettings(); var version = CreateUmbracoVersion(9, 1, 1); var versionPackageName = "VersionPackage"; var packageVersion = "1.0.0"; @@ -66,7 +65,7 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry new () { PackageName = noVersionPackageName } }; var manifestParser = CreateManifestParser(manifests); - var sut = new TelemetryService(globalSettings, manifestParser, version); + var sut = new TelemetryService(manifestParser, version, createSiteIdentifierService()); var success = sut.TryGetTelemetryReportData(out var telemetry); @@ -87,15 +86,14 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry [Test] public void RespectsAllowPackageTelemetry() { - var globalSettings = CreateGlobalSettings(); var version = CreateUmbracoVersion(9, 1, 1); PackageManifest[] manifests = { new () { PackageName = "DoNotTrack", AllowPackageTelemetry = false }, - new () { PackageName = "TrackingAllowed", AllowPackageTelemetry = true } + new () { PackageName = "TrackingAllowed", AllowPackageTelemetry = true }, }; var manifestParser = CreateManifestParser(manifests); - var sut = new TelemetryService(globalSettings, manifestParser, version); + var sut = new TelemetryService(manifestParser, version, createSiteIdentifierService()); var success = sut.TryGetTelemetryReportData(out var telemetry); @@ -121,15 +119,12 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry return Mock.Of(x => x.SemanticVersion == version); } - private IOptionsMonitor CreateGlobalSettings(string guidString = null) + private ISiteIdentifierService createSiteIdentifierService(bool shouldSucceed = true) { - if (guidString is null) - { - guidString = Guid.NewGuid().ToString(); - } - - var globalSettings = new GlobalSettings { Id = guidString }; - return Mock.Of>(x => x.CurrentValue == globalSettings); + var mock = new Mock(); + var siteIdentifier = shouldSucceed ? Guid.NewGuid() : Guid.Empty; + mock.Setup(x => x.TryGetOrCreateSiteIdentifier(out siteIdentifier)).Returns(shouldSucceed); + return mock.Object; } } }