v9: Implement telemetry levels (#12267)

* Add initial classes

* Add TelemetryProviders

* Add new NodeCountService.cs and NodeTelemetryProvider

* Add data contract attribute to UsageInformation

Otherwise it wont serialize correctly

* Implement more providers

* Fix builders and propertyEditorTelemetry

* Add MediaTelemetryProvider

* Add MediaTelemetryProvider

* Fix doubling of media telemetry

* Move contentCount from NodeCountTelemetryProvider and move to ContentTelemetryProvider

* Revert ContentTelemetryProvider changes

* Add detailed information to TelemetryService

* Add integration tests

* Add more tests and todos for tests

* Fix stylecop warnings

* Use yield return instead of instantiating local list

* Implement Macro test

* Inject interface instead of implementation in TelemetryService

* Fix TelemetryServiceTests.cs

* Implement media tests

* Implement propertyTypeTests

* Implement constants instead of hardcoded strings

* Add SystemInformationTelemetryProvider

* Use SystemInformationTableDataProvider in UserDataService

* Implement more properties

* Add UsageInformation

* Replace UserDataService with SystemInformationTelemetryProvider

* Undo changes to UserDataService and obsolete it

* Remove ISystemInformationTableDataProvider

* Register SystemInformationTelemetryProvider as telemetry provider

* Use constants for telemetry names

* Make UserDataServiceTests test SystemInformationTelemetryProvider instead

* Update UserDataServiceTests to cover new data

* Add unit tests

* Add integration test testing expected data is returned

* Implement Analytics dashboard

* Improve assertion message

* Add text and styling to analyticspage

* Rename consent to analytic

* implement save button for consent level

* Implement save button

* Fix system information test

* Add TelemetryResource

* Move telemetry providers to infrastructure

* Add database provider to system information

* Set startvalue for slider

* Fix unit tests

* Implement MetricsConsentService using KeyValueService

* Return void hen setting the telemetry level

* fix startposition when not reloading

* Add a couple tests

* Update src/Umbraco.Core/Services/MetricsConsentService.cs

* Rename ConsentLevel.cs

* Use direct Enum instead of parsing

* rename consent resource

* add lazy database

* refactor slider

* Implement ng-if and propers pips

* Make classes internal

* Fix slider not loading when navigating to tab

* Add telemetry level check to TelemetryService.cs

* Add Consent for analytics text

* Fix build errors for unit tests

* Fix TelemetryServiceTests

* revert package-lock.json

* Fix integration test

* Update slider

* Update TelemetryService.cs

* Apply suggestions from code review

Co-authored-by: Mole <nikolajlauridsen@protonmail.ch>

Co-authored-by: Nikolaj Geisle <niko737@edu.ucl.dk>
Co-authored-by: nikolajlauridsen <nikolajlauridsen@protonmail.ch>
This commit is contained in:
Nikolaj Geisle
2022-04-19 15:06:10 +02:00
committed by GitHub
parent 2d31913837
commit c07ffb68fc
50 changed files with 1597 additions and 26 deletions

View File

@@ -20,7 +20,7 @@ context('System Information', () => {
it('Check System Info Displays', () => {
openSystemInformation();
cy.get('.table').find('tr').should('have.length', 10);
cy.get('.table').find('tr').should('have.length', 13);
cy.contains('Current Culture').parent().should('contain', 'en-US');
cy.contains('Current UI Culture').parent().should('contain', 'en-US');
});

View File

@@ -0,0 +1,40 @@
using NUnit.Framework;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services
{
[TestFixture]
[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
public class MetricsConsentServiceTest : UmbracoIntegrationTest
{
private IMetricsConsentService MetricsConsentService => GetRequiredService<IMetricsConsentService>();
private IKeyValueService KeyValueService => GetRequiredService<IKeyValueService>();
[Test]
[TestCase(TelemetryLevel.Minimal)]
[TestCase(TelemetryLevel.Basic)]
[TestCase(TelemetryLevel.Detailed)]
public void Can_Store_Consent(TelemetryLevel level)
{
MetricsConsentService.SetConsentLevel(level);
var actual = MetricsConsentService.GetConsentLevel();
Assert.IsNotNull(actual);
Assert.AreEqual(level, actual);
}
[Test]
public void Enum_Stored_as_string()
{
MetricsConsentService.SetConsentLevel(TelemetryLevel.Detailed);
var stringValue = KeyValueService.GetValue(Cms.Core.Services.MetricsConsentService.Key);
Assert.AreEqual("Detailed", stringValue);
}
}
}

View File

@@ -0,0 +1,351 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.Collections.Generic;
using System.Linq;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Cache;
using Umbraco.Cms.Core.DependencyInjection;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.Membership;
using Umbraco.Cms.Core.Scoping;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement;
using Umbraco.Cms.Infrastructure.Telemetry.Providers;
using Umbraco.Cms.Tests.Common.Builders;
using Umbraco.Cms.Tests.Common.Builders.Extensions;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services
{
/// <summary>
/// Tests covering the SectionService
/// </summary>
[TestFixture]
[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
public class TelemetryProviderTests : UmbracoIntegrationTest
{
private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
private IFileService FileService => GetRequiredService<IFileService>();
private IDomainService DomainService => GetRequiredService<IDomainService>();
private IContentService ContentService => GetRequiredService<IContentService>();
private DomainTelemetryProvider DetailedTelemetryProviders => GetRequiredService<DomainTelemetryProvider>();
private ContentTelemetryProvider ContentTelemetryProvider => GetRequiredService<ContentTelemetryProvider>();
private LanguagesTelemetryProvider LanguagesTelemetryProvider => GetRequiredService<LanguagesTelemetryProvider>();
private UserTelemetryProvider UserTelemetryProvider => GetRequiredService<UserTelemetryProvider>();
private MacroTelemetryProvider MacroTelemetryProvider => GetRequiredService<MacroTelemetryProvider>();
private MediaTelemetryProvider MediaTelemetryProvider => GetRequiredService<MediaTelemetryProvider>();
private PropertyEditorTelemetryProvider PropertyEditorTelemetryProvider => GetRequiredService<PropertyEditorTelemetryProvider>();
private ILocalizationService LocalizationService => GetRequiredService<ILocalizationService>();
private IUserService UserService => GetRequiredService<IUserService>();
private IMediaService MediaService => GetRequiredService<IMediaService>();
private IMediaTypeService MediaTypeService => GetRequiredService<IMediaTypeService>();
private LanguageBuilder _languageBuilder = new();
private UserBuilder _userBuilder = new();
private UserGroupBuilder _userGroupBuilder = new();
private ContentTypeBuilder _contentTypeBuilder = new ();
protected override void CustomTestSetup(IUmbracoBuilder builder)
{
builder.Services.AddTransient<DomainTelemetryProvider>();
builder.Services.AddTransient<ContentTelemetryProvider>();
builder.Services.AddTransient<LanguagesTelemetryProvider>();
builder.Services.AddTransient<UserTelemetryProvider>();
builder.Services.AddTransient<MacroTelemetryProvider>();
builder.Services.AddTransient<MediaTelemetryProvider>();
builder.Services.AddTransient<PropertyEditorTelemetryProvider>();
base.CustomTestSetup(builder);
}
[Test]
public void Domain_Telemetry_Provider_Can_Get_Domains()
{
// Arrange
DomainService.Save(new UmbracoDomain("danish", "da-DK"));
IEnumerable<UsageInformation> result = null;
// Act
result = DetailedTelemetryProviders.GetInformation();
// Assert
Assert.AreEqual(1, result.First().Data);
}
[Test]
public void SectionService_Can_Get_Allowed_Sections_For_User()
{
// Arrange
Template template = TemplateBuilder.CreateTextPageTemplate();
FileService.SaveTemplate(template);
ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
ContentTypeService.Save(contentType);
Content blueprint = ContentBuilder.CreateTextpageContent(contentType, "hello", Constants.System.Root);
blueprint.SetValue("title", "blueprint 1");
blueprint.SetValue("bodyText", "blueprint 2");
blueprint.SetValue("keywords", "blueprint 3");
blueprint.SetValue("description", "blueprint 4");
ContentService.SaveBlueprint(blueprint);
IContent fromBlueprint = ContentService.CreateContentFromBlueprint(blueprint, "My test content");
ContentService.Save(fromBlueprint);
IEnumerable<UsageInformation> result = null;
// Act
result = ContentTelemetryProvider.GetInformation();
// Assert
// TODO : Test multiple roots, with children + grandchildren
Assert.AreEqual(1, result.First().Data);
}
[Test]
public void Language_Telemetry_Can_Get_Languages()
{
// Arrange
var langTwo = _languageBuilder.WithCultureInfo("da-DK").Build();
var langThree = _languageBuilder.WithCultureInfo("se-SV").Build();
LocalizationService.Save(langTwo);
LocalizationService.Save(langThree);
IEnumerable<UsageInformation> result = null;
// Act
result = LanguagesTelemetryProvider.GetInformation();
// Assert
Assert.AreEqual(3, result.First().Data);
}
[Test]
public void MacroTelemetry_Can_Get_Macros()
{
BuildMacros();
var result = MacroTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.MacroCount);
Assert.AreEqual(3, result.Data);
}
[Test]
public void MediaTelemetry_Can_Get_Media_In_Folders()
{
IMediaType folderType = MediaTypeService.Get(1031);
IMediaType imageMediaType = MediaTypeService.Get(1032);
Media root = MediaBuilder.CreateMediaFolder(folderType, -1);
MediaService.Save(root);
int createdMediaCount = 10;
for (int i = 0; i < createdMediaCount; i++)
{
Media c1 = MediaBuilder.CreateMediaImage(imageMediaType, root.Id);
MediaService.Save(c1);
}
var result = MediaTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.MediaCount);
Assert.AreEqual(createdMediaCount, result.Data);
}
[Test]
public void MediaTelemetry_Can_Get_Media_In_Root()
{
IMediaType imageMediaType = MediaTypeService.Get(1032);
int createdMediaCount = 10;
for (int i = 0; i < createdMediaCount; i++)
{
Media c1 = MediaBuilder.CreateMediaImage(imageMediaType, -1);
MediaService.Save(c1);
}
var result = MediaTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.MediaCount);
Assert.AreEqual(createdMediaCount, result.Data);
}
[Test]
public void PropertyEditorTelemetry_Counts_Same_Editor_As_One()
{
ContentType ct2 = ContentTypeBuilder.CreateBasicContentType("ct2", "CT2", null);
AddPropType("title", -88, ct2);
ContentType ct3 = ContentTypeBuilder.CreateBasicContentType("ct3", "CT3", null);
AddPropType("title",-88, ct3);
ContentType ct5 = ContentTypeBuilder.CreateBasicContentType("ct5", "CT5", null);
AddPropType("blah", -88, ct5);
ContentTypeService.Save(ct2);
ContentTypeService.Save(ct3);
ContentTypeService.Save(ct5);
var properties = PropertyEditorTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.Properties);
var result = properties.Data as IEnumerable<string>;
Assert.AreEqual(1, result?.Count());
}
[Test]
public void PropertyEditorTelemetry_Can_Get_All_PropertyTypes()
{
ContentType ct2 = ContentTypeBuilder.CreateBasicContentType("ct2", "CT2", null);
AddPropType("title", -88, ct2);
AddPropType("title",-99, ct2);
ContentType ct5 = ContentTypeBuilder.CreateBasicContentType("ct5", "CT5", null);
AddPropType("blah", -88, ct5);
ContentTypeService.Save(ct2);
ContentTypeService.Save(ct5);
var properties = PropertyEditorTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.Properties);
var result = properties.Data as IEnumerable<string>;
Assert.AreEqual(2, result?.Count());
}
[Test]
public void UserTelemetry_Can_Get_Default_User()
{
var result = UserTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.UserCount);
Assert.AreEqual(1, result.Data);
}
[Test]
public void UserTelemetry_Can_Get_With_Saved_User()
{
var user = BuildUser(0);
UserService.Save(user);
var result = UserTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.UserCount);
Assert.AreEqual(2, result.Data);
}
[Test]
public void UserTelemetry_Can_Get_More_Users()
{
int totalUsers = 99;
var users = BuildUsers(totalUsers);
UserService.Save(users);
var result = UserTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.UserCount);
Assert.AreEqual(totalUsers + 1, result.Data);
}
[Test]
public void UserTelemetry_Can_Get_Default_UserGroups()
{
var result = UserTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.UserGroupCount);
Assert.AreEqual(5, result.Data);
}
[Test]
public void UserTelemetry_Can_Get_With_Saved_UserGroups()
{
var userGroup = BuildUserGroup("testGroup");
UserService.Save(userGroup);
var result = UserTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.UserGroupCount);
Assert.AreEqual(6, result.Data);
}
[Test]
public void UserTelemetry_Can_Get_More_UserGroups()
{
var userGroups = BuildUserGroups(100);
foreach (var userGroup in userGroups)
{
UserService.Save(userGroup);
}
var result = UserTelemetryProvider.GetInformation().FirstOrDefault(x => x.Name == Constants.Telemetry.UserGroupCount);
Assert.AreEqual(105, result.Data);
}
private User BuildUser(int count) =>
_userBuilder
.WithLogin($"username{count}", "test pass")
.WithName("Test" + count)
.WithEmail($"test{count}@test.com")
.Build();
private IEnumerable<User> BuildUsers(int count)
{
for (int i = 0; i < count; i++)
{
yield return BuildUser(count);
}
}
private IUserGroup BuildUserGroup(string alias) =>
_userGroupBuilder
.WithAlias(alias)
.WithName(alias)
.WithAllowedSections(new List<string>(){"A", "B"})
.Build();
private IEnumerable<IUserGroup> BuildUserGroups(int count)
{
for (int i = 0; i < count; i++)
{
yield return BuildUserGroup(i.ToString());
}
}
private void BuildMacros()
{
IScopeProvider scopeProvider = ScopeProvider;
using (IScope scope = scopeProvider.CreateScope())
{
var repository = new MacroRepository((IScopeAccessor)scopeProvider, AppCaches.Disabled, Mock.Of<ILogger<MacroRepository>>(), ShortStringHelper);
repository.Save(new Macro(ShortStringHelper, "test1", "Test1", "~/views/macropartials/test1.cshtml"));
repository.Save(new Macro(ShortStringHelper, "test2", "Test2", "~/views/macropartials/test2.cshtml"));
repository.Save(new Macro(ShortStringHelper, "test3", "Tet3", "~/views/macropartials/test3.cshtml"));
scope.Complete();
}
}
private void AddPropType(string alias, int dataTypeId, IContentType ct)
{
var contentCollection = new PropertyTypeCollection(true)
{
new PropertyType(ShortStringHelper, Constants.PropertyEditors.Aliases.TextBox, ValueStorageType.Ntext) { Alias = alias, Name = "Title", Description = string.Empty, Mandatory = false, SortOrder = 1, DataTypeId = dataTypeId },
};
var pg = new PropertyGroup(contentCollection)
{
Alias = "test",
Name = "test",
SortOrder = 1
};
ct.PropertyGroups.Add(pg);
}
}
}

View File

@@ -0,0 +1,77 @@
using System;
using System.Linq;
using Microsoft.Extensions.DependencyInjection;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.DependencyInjection;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Telemetry;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Telemetry
{
[TestFixture]
[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
public class TelemetryServiceTests : UmbracoIntegrationTest
{
protected override void CustomTestSetup(IUmbracoBuilder builder)
{
builder.Services.Configure<GlobalSettings>(options => options.Id = Guid.NewGuid().ToString());
}
private ITelemetryService TelemetryService => GetRequiredService<ITelemetryService>();
private IMetricsConsentService MetricsConsentService => GetRequiredService<IMetricsConsentService>();
[Test]
public void Expected_Detailed_Telemetry_Exists()
{
var expectedData = new string[]
{
Constants.Telemetry.RootCount,
Constants.Telemetry.DomainCount,
Constants.Telemetry.ExamineIndexCount,
Constants.Telemetry.LanguageCount,
Constants.Telemetry.MacroCount,
Constants.Telemetry.MediaCount,
Constants.Telemetry.MediaCount,
Constants.Telemetry.TemplateCount,
Constants.Telemetry.ContentCount,
Constants.Telemetry.DocumentTypeCount,
Constants.Telemetry.Properties,
Constants.Telemetry.UserCount,
Constants.Telemetry.UserGroupCount,
Constants.Telemetry.ServerOs,
Constants.Telemetry.ServerFramework,
Constants.Telemetry.OsLanguage,
Constants.Telemetry.WebServer,
Constants.Telemetry.ModelsBuilderMode,
Constants.Telemetry.CustomUmbracoPath,
Constants.Telemetry.AspEnvironment,
Constants.Telemetry.IsDebug,
Constants.Telemetry.DatabaseProvider,
};
MetricsConsentService.SetConsentLevel(TelemetryLevel.Detailed);
var success = TelemetryService.TryGetTelemetryReportData(out var telemetryReportData);
var detailed = telemetryReportData.Detailed.ToArray();
Assert.IsTrue(success);
Assert.Multiple(() =>
{
Assert.IsNotNull(detailed);
Assert.AreEqual(expectedData.Length, detailed.Length);
foreach (var expectedInfo in expectedData)
{
var expected = detailed.FirstOrDefault(x => x.Name == expectedInfo);
Assert.IsNotNull(expected, $"Expected {expectedInfo} to exists in the detailed list");
}
});
}
}
}

View File

@@ -1,13 +1,19 @@
using System.Collections.Generic;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core.Configuration;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Semver;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Infrastructure.Persistence;
using Umbraco.Cms.Infrastructure.Telemetry.Providers;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Services
{
@@ -86,10 +92,49 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Services
});
}
private UserDataService CreateUserDataService(string culture)
[Test]
[TestCase(ModelsMode.Nothing)]
[TestCase(ModelsMode.InMemoryAuto)]
[TestCase(ModelsMode.SourceCodeAuto)]
[TestCase(ModelsMode.SourceCodeManual)]
public void ReportsModelsModeCorrectly(ModelsMode modelsMode)
{
var userDataService = CreateUserDataService(modelsMode: modelsMode);
UserData[] userData = userDataService.GetUserData().ToArray();
var actual = userData.FirstOrDefault(x => x.Name == "Models Builder Mode");
Assert.IsNotNull(actual?.Data);
Assert.AreEqual(modelsMode.ToString(), actual.Data);
}
[Test]
[TestCase(true)]
[TestCase(false)]
public void ReportsDebugModeCorrectly(bool isDebug)
{
var userDataService = CreateUserDataService(isDebug: isDebug);
UserData[] userData = userDataService.GetUserData().ToArray();
var actual = userData.FirstOrDefault(x => x.Name == "Debug Mode");
Assert.IsNotNull(actual?.Data);
Assert.AreEqual(isDebug.ToString(), actual.Data);
}
private SystemInformationTelemetryProvider CreateUserDataService(string culture = "", ModelsMode modelsMode = ModelsMode.InMemoryAuto, bool isDebug = true)
{
var localizationService = CreateILocalizationService(culture);
return new UserDataService(_umbracoVersion, localizationService);
var databaseMock = new Mock<IUmbracoDatabase>();
databaseMock.Setup(x => x.DatabaseType.GetProviderName()).Returns("SQL");
return new SystemInformationTelemetryProvider(
_umbracoVersion,
localizationService,
Mock.Of<IOptions<ModelsBuilderSettings>>(x => x.Value == new ModelsBuilderSettings { ModelsMode = modelsMode }),
Mock.Of<IOptions<HostingSettings>>(x => x.Value == new HostingSettings { Debug = isDebug }),
Mock.Of<IOptions<GlobalSettings>>(x => x.Value == new GlobalSettings()),
Mock.Of<IHostEnvironment>(),
new Lazy<IUmbracoDatabase>(databaseMock.Object));
}
private ILocalizationService CreateILocalizationService(string culture)

View File

@@ -0,0 +1,121 @@
using System;
using System.Globalization;
using System.Linq;
using System.Threading;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Configuration;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Infrastructure.Persistence;
using Umbraco.Cms.Infrastructure.Telemetry.Providers;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry
{
[TestFixture]
public class SystemInformationTelemetryProviderTests
{
[Test]
[TestCase(ModelsMode.Nothing)]
[TestCase(ModelsMode.InMemoryAuto)]
[TestCase(ModelsMode.SourceCodeAuto)]
[TestCase(ModelsMode.SourceCodeManual)]
public void ReportsModelsModeCorrectly(ModelsMode modelsMode)
{
var telemetryProvider = CreateProvider(modelsMode: modelsMode);
UsageInformation[] usageInformation = telemetryProvider.GetInformation().ToArray();
var actual = usageInformation.FirstOrDefault(x => x.Name == Constants.Telemetry.ModelsBuilderMode);
Assert.IsNotNull(actual?.Data);
Assert.AreEqual(modelsMode.ToString(), actual.Data);
}
[Test]
[TestCase(true)]
[TestCase(false)]
public void ReportsDebugModeCorrectly(bool isDebug)
{
var telemetryProvider = CreateProvider(isDebug: isDebug);
UsageInformation[] usageInformation = telemetryProvider.GetInformation().ToArray();
var actual = usageInformation.FirstOrDefault(x => x.Name == Constants.Telemetry.IsDebug);
Assert.IsNotNull(actual?.Data);
Assert.AreEqual(isDebug, actual.Data);
}
[Test]
[TestCase("en-US")]
[TestCase("de-DE")]
[TestCase("en-NZ")]
[TestCase("sv-SE")]
public void ReportsOsLanguageCorrectly(string culture)
{
Thread.CurrentThread.CurrentCulture = new CultureInfo(culture);
var telemetryProvider = CreateProvider();
UsageInformation[] usageInformation = telemetryProvider.GetInformation().ToArray();
var actual = usageInformation.FirstOrDefault(x => x.Name == Constants.Telemetry.OsLanguage);
Assert.NotNull(actual?.Data);
Assert.AreEqual(culture, actual.Data.ToString());
}
[Test]
[TestCase(GlobalSettings.StaticUmbracoPath, false)]
[TestCase("mycustompath", true)]
[TestCase("~/notUmbraco", true)]
[TestCase("/umbraco", true)]
[TestCase("umbraco", true)]
public void ReportsCustomUmbracoPathCorrectly(string path, bool isCustom)
{
var telemetryProvider = CreateProvider(umbracoPath: path);
UsageInformation[] usageInformation = telemetryProvider.GetInformation().ToArray();
var actual = usageInformation.FirstOrDefault(x => x.Name == Constants.Telemetry.CustomUmbracoPath);
Assert.NotNull(actual?.Data);
Assert.AreEqual(isCustom, actual.Data);
}
[Test]
[TestCase("Development")]
[TestCase("Staging")]
[TestCase("Production")]
public void ReportsCorrectAspEnvironment(string environment)
{
var telemetryProvider = CreateProvider(environment: environment);
UsageInformation[] usageInformation = telemetryProvider.GetInformation().ToArray();
var actual = usageInformation.FirstOrDefault(x => x.Name == Constants.Telemetry.AspEnvironment);
Assert.NotNull(actual?.Data);
Assert.AreEqual(environment, actual.Data);
}
private SystemInformationTelemetryProvider CreateProvider(
ModelsMode modelsMode = ModelsMode.InMemoryAuto,
bool isDebug = true,
string umbracoPath = "",
string environment = "")
{
var hostEnvironment = new Mock<IHostEnvironment>();
hostEnvironment.Setup(x => x.EnvironmentName).Returns(environment);
var databaseMock = new Mock<IUmbracoDatabase>();
databaseMock.Setup(x => x.DatabaseType.GetProviderName()).Returns("SQL");
return new SystemInformationTelemetryProvider(
Mock.Of<IUmbracoVersion>(),
Mock.Of<ILocalizationService>(),
Mock.Of<IOptions<ModelsBuilderSettings>>(x => x.Value == new ModelsBuilderSettings{ ModelsMode = modelsMode }),
Mock.Of<IOptions<HostingSettings>>(x => x.Value == new HostingSettings { Debug = isDebug }),
Mock.Of<IOptions<GlobalSettings>>(x => x.Value == new GlobalSettings{ UmbracoPath = umbracoPath }),
hostEnvironment.Object,
new Lazy<IUmbracoDatabase>(databaseMock.Object));
}
}
}

View File

@@ -1,13 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Extensions.Options;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core.Configuration;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Manifest;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Semver;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Telemetry;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry
@@ -20,7 +20,8 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry
{
var version = CreateUmbracoVersion(9, 3, 1);
var siteIdentifierServiceMock = new Mock<ISiteIdentifierService>();
var sut = new TelemetryService(Mock.Of<IManifestParser>(), version, siteIdentifierServiceMock.Object);
var usageInformationServiceMock = new Mock<IUsageInformationService>();
var sut = new TelemetryService(Mock.Of<IManifestParser>(), version, siteIdentifierServiceMock.Object, usageInformationServiceMock.Object, Mock.Of<IMetricsConsentService>());
Guid guid;
var result = sut.TryGetTelemetryReportData(out var telemetryReportData);
@@ -31,7 +32,7 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry
public void SkipsIfCantGetOrCreateId()
{
var version = CreateUmbracoVersion(9, 3, 1);
var sut = new TelemetryService(Mock.Of<IManifestParser>(), version, createSiteIdentifierService(false));
var sut = new TelemetryService(Mock.Of<IManifestParser>(), version, createSiteIdentifierService(false), Mock.Of<IUsageInformationService>(), Mock.Of<IMetricsConsentService>());
var result = sut.TryGetTelemetryReportData(out var telemetry);
@@ -44,7 +45,7 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry
{
var version = CreateUmbracoVersion(9, 1, 1, "-rc", "-ad2f4k2d");
var sut = new TelemetryService(Mock.Of<IManifestParser>(), version, createSiteIdentifierService());
var sut = new TelemetryService(Mock.Of<IManifestParser>(), version, createSiteIdentifierService(), Mock.Of<IUsageInformationService>(), Mock.Of<IMetricsConsentService>());
var result = sut.TryGetTelemetryReportData(out var telemetry);
@@ -65,7 +66,9 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry
new () { PackageName = noVersionPackageName }
};
var manifestParser = CreateManifestParser(manifests);
var sut = new TelemetryService(manifestParser, version, createSiteIdentifierService());
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);
var success = sut.TryGetTelemetryReportData(out var telemetry);
@@ -93,7 +96,9 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Telemetry
new () { PackageName = "TrackingAllowed", AllowPackageTelemetry = true },
};
var manifestParser = CreateManifestParser(manifests);
var sut = new TelemetryService(manifestParser, version, createSiteIdentifierService());
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);
var success = sut.TryGetTelemetryReportData(out var telemetry);