yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/v10/dev' into v10/feature/nullable-reference-types-in-Umbraco.Web.Backoffice

Browse Source 
# Conflicts:
#	src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Collections.cs
#	src/Umbraco.Core/Extensions/PublishedContentExtensions.cs
#	src/Umbraco.Core/Telemetry/Models/TelemetryReportData.cs
#	src/Umbraco.Infrastructure/PropertyEditors/ValueConverters/MultiUrlPickerValueConverter.cs
#	src/Umbraco.PublishedCache.NuCache/ContentStore.cs
#	src/Umbraco.Web.BackOffice/Trees/MemberTypeTreeController.cs
#	src/Umbraco.Web.Common/ModelsBuilder/InMemoryModelFactory.cs
#	src/Umbraco.Web.Common/Security/MemberManager.cs
#	src/Umbraco.Web.Website/Routing/ControllerActionSearcher.cs
#	src/Umbraco.Web.Website/Routing/IControllerActionSearcher.cs
#	src/Umbraco.Web.Website/Routing/UmbracoRouteValueTransformer.cs
This commit is contained in:
Nikolaj Geisle
2022-04-21 10:26:51 +02:00
parent c72a4ff188 536440b729
commit 060e0181a7
172 changed files with 4578 additions and 1710 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/Umbraco.Tests.AcceptanceTest/cypress/integration/HelpPanel/systemInformation.ts
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');
});

2
tests/Umbraco.Tests.AcceptanceTest/cypress/integration/Tours/backofficeTour.ts
View File

@@ -93,7 +93,7 @@ function runBackOfficeIntroTour(percentageComplete, buttonText, timeout) {
cy.get('.umb-tour-step__counter', { timeout: timeout }).contains('9/13');
cy.get('.umb-tour-step__footer .umb-button').should('be.visible').click();
cy.get('.umb-tour-step__counter', { timeout: timeout }).contains('10/13');
cy.get('.umb-overlay-drawer__align-right .umb-button').should('be.visible').click();
cy.get('[data-element~="overlay-user"] [data-element="button-overlayClose"]').should('be.visible').click();
cy.get('.umb-tour-step__counter', { timeout: timeout }).contains('11/13');
cy.umbracoGlobalHelp().click()

6
tests/Umbraco.Tests.AcceptanceTest/package-lock.json generated
View File

@@ -3530,9 +3530,9 @@
}
},
"minimist": {
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
"integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==",
"version": "1.2.6",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz",
"integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==",
"dev": true
},
"ms": {

12
tests/Umbraco.Tests.Benchmarks/Umbraco.Tests.Benchmarks.csproj
View File

@@ -1,21 +1,26 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<OutputType>Exe</OutputType>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<None Remove="CtorInvokeBenchmarks.cs.bak" />
<None Remove="ReflectionUtilities-Unused.cs.bak" />
</ItemGroup>
<ItemGroup>
<None Include="app.config" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\src\Umbraco.Cms.Persistence.SqlServer\Umbraco.Cms.Persistence.SqlServer.csproj" />
<ProjectReference Include="..\..\src\Umbraco.Core\Umbraco.Core.csproj" />
<ProjectReference Include="..\..\src\Umbraco.Infrastructure\Umbraco.Infrastructure.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="BenchmarkDotNet">
<Version>0.13.1</Version>
@@ -26,7 +31,8 @@
<PackageReference Include="Moq">
<Version>4.16.1</Version>
</PackageReference>
<PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
<PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
<PackageReference Include="System.Reflection.Emit" Version="4.7.0" />
</ItemGroup>
</ItemGroup>
</Project>

1
tests/Umbraco.Tests.Common/Umbraco.Tests.Common.csproj
View File

@@ -6,6 +6,7 @@
<PackageId>Umbraco.Cms.Tests</PackageId>
<Title>Umbraco CMS Test Tools</Title>
<Description>Contains commonly used tools to write tests for Umbraco CMS, such as various builders for content etc.</Description>
<IsPackable>true</IsPackable>
</PropertyGroup>
<ItemGroup>

40
tests/Umbraco.Tests.Integration/Umbraco.Core/Services/MetricsConsentServiceTest.cs Normal file
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);
}
}
}

352
tests/Umbraco.Tests.Integration/Umbraco.Core/Services/TelemetryProviderTests.cs Normal file
View File

@@ -0,0 +1,352 @@
// 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.Scoping;
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);
}
}
}

77
tests/Umbraco.Tests.Integration/Umbraco.Core/Telemetry/TelemetryServiceTests.cs Normal file
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");
}
});
}
}
}

5
tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Security/BackOfficeUserStoreTests.cs
View File

@@ -27,6 +27,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Security
private IExternalLoginWithKeyService ExternalLoginService => GetRequiredService<IExternalLoginWithKeyService>();
private IUmbracoMapper UmbracoMapper => GetRequiredService<IUmbracoMapper>();
private ILocalizedTextService TextService => GetRequiredService<ILocalizedTextService>();
private ITwoFactorLoginService TwoFactorLoginService => GetRequiredService<ITwoFactorLoginService>();
private BackOfficeUserStore GetUserStore()
=> new BackOfficeUserStore(
@@ -37,7 +38,9 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Security
new TestOptionsSnapshot<GlobalSettings>(GlobalSettings),
UmbracoMapper,
new BackOfficeErrorDescriber(TextService),
AppCaches);
AppCaches,
TwoFactorLoginService
);
[Test]
public async Task Can_Persist_Is_Approved()

52
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/UserDataServiceTests.cs
View File

@@ -1,13 +1,20 @@
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 NPoco;
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 +93,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<IOptionsMonitor<ModelsBuilderSettings>>(x => x.CurrentValue == new ModelsBuilderSettings { ModelsMode = modelsMode }),
Mock.Of<IOptionsMonitor<HostingSettings>>(x => x.CurrentValue == new HostingSettings { Debug = isDebug }),
Mock.Of<IOptionsMonitor<GlobalSettings>>(x => x.CurrentValue == new GlobalSettings()),
Mock.Of<IHostEnvironment>(),
Mock.Of<IUmbracoDatabaseFactory>(x=>x.CreateDatabase() == Mock.Of<IUmbracoDatabase>(y=>y.DatabaseType == DatabaseType.SQLite)));
}
private ILocalizationService CreateILocalizationService(string culture)

122
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/SystemInformationTelemetryProviderTests.cs Normal file
View File

@@ -0,0 +1,122 @@
using System;
using System.Globalization;
using System.Linq;
using System.Threading;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Moq;
using NPoco;
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<IOptionsMonitor<ModelsBuilderSettings>>(x => x.CurrentValue == new ModelsBuilderSettings{ ModelsMode = modelsMode }),
Mock.Of<IOptionsMonitor<HostingSettings>>(x => x.CurrentValue == new HostingSettings { Debug = isDebug }),
Mock.Of<IOptionsMonitor<GlobalSettings>>(x => x.CurrentValue == new GlobalSettings{ UmbracoPath = umbracoPath }),
hostEnvironment.Object,
Mock.Of<IUmbracoDatabaseFactory>(x=>x.CreateDatabase() == Mock.Of<IUmbracoDatabase>(y=>y.DatabaseType == DatabaseType.SQLite)));
}
}
}

21
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/TelemetryServiceTests.cs
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,9 @@ 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 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);
var result = sut.TryGetTelemetryReportData(out var telemetry);
@@ -65,7 +68,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 +98,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);

4
tests/Umbraco.Tests.UnitTests/Umbraco.Tests.UnitTests.csproj
View File

@@ -3,15 +3,15 @@
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<IsPackable>false</IsPackable>
<RootNamespace>Umbraco.Cms.Tests.UnitTests</RootNamespace>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup Condition="'$(OS)' == 'Windows_NT'">
<PackageReference Include="Microsoft.ICU.ICU4C.Runtime" Version="68.2.0.9" />
<RuntimeHostConfigurationOption Include="System.Globalization.AppLocalIcu" Value="68.2" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\src\Umbraco.PublishedCache.NuCache\Umbraco.PublishedCache.NuCache.csproj" />
<ProjectReference Include="..\Umbraco.Tests.Common\Umbraco.Tests.Common.csproj" />