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

Added unit tests for ContentVersionService (#11597)

Browse Source 
* Added unit tests for ContentVersionService

* Clean up

* Fixed tests after using ConfigureMembers = true

* Fixed tests after using ConfigureMembers = true
This commit is contained in:
Bjarke Berg
2021-11-09 17:48:50 +01:00
committed by GitHub
parent 90c64a22c7
commit 17abf0474c
4 changed files with 203 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/Umbraco.Infrastructure/Services/Implement/ContentVersionService.cs
View File

@@ -41,11 +41,14 @@ namespace Umbraco.Cms.Core.Services.Implement
/// In v9 this can live in another class as we publish the notifications via IEventAggregator.
/// But for v8 must be here for access to the static events.
/// </remarks>
public IReadOnlyCollection<HistoricContentVersionMeta> PerformContentVersionCleanup(DateTime asAtDate) =>
CleanupDocumentVersions(asAtDate);
public IReadOnlyCollection<HistoricContentVersionMeta> PerformContentVersionCleanup(DateTime asAtDate)
{
// Media - ignored
// Members - ignored
return CleanupDocumentVersions(asAtDate);
}
// Media - ignored
// Members - ignored
/// <remarks>
/// v9 - move to another class
/// </remarks>

17
tests/Umbraco.Tests.UnitTests/AutoFixture/AutoMoqDataAttribute.cs
View File

@@ -21,10 +21,12 @@ using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Web.BackOffice.Controllers;
using Umbraco.Cms.Web.BackOffice.Install;
using Umbraco.Cms.Web.BackOffice.Routing;
using Umbraco.Cms.Web.Common.AspNetCore;
using Umbraco.Cms.Web.Common.Security;
namespace Umbraco.Cms.Tests.UnitTests.AutoFixture
{
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor)]
public class AutoMoqDataAttribute : AutoDataAttribute
{
@@ -40,6 +42,7 @@ namespace Umbraco.Cms.Tests.UnitTests.AutoFixture
internal static class AutoMockCustomizations
{
public static IFixture Default => new Fixture().Customize(new UmbracoCustomization());
private class UmbracoCustomization : ICustomization
@@ -58,7 +61,7 @@ namespace Umbraco.Cms.Tests.UnitTests.AutoFixture
.Customize(new ConstructorCustomization(typeof(BackOfficeUserManager), new GreedyConstructorQuery()))
.Customize(new ConstructorCustomization(typeof(MemberManager), new GreedyConstructorQuery()));
fixture.Customize(new AutoMoqCustomization());
fixture.Customize(new AutoMoqCustomization(){ConfigureMembers = true});
// When requesting an IUserStore ensure we actually uses a IUserLockoutStore
fixture.Customize<IUserStore<BackOfficeIdentityUser>>(cc => cc.FromFactory(() => Mock.Of<IUserLockoutStore<BackOfficeIdentityUser>>()));
@@ -71,6 +74,8 @@ namespace Umbraco.Cms.Tests.UnitTests.AutoFixture
u => u.FromFactory(
() => new UmbracoVersion()));
fixture.Customize<HostingSettings>(x =>
x.With(settings => settings.ApplicationVirtualPath, string.Empty));
fixture.Customize<BackOfficeAreaRoutes>(u => u.FromFactory(
() => new BackOfficeAreaRoutes(
Options.Create(new GlobalSettings()),
@@ -84,12 +89,18 @@ namespace Umbraco.Cms.Tests.UnitTests.AutoFixture
Mock.Of<IHostingEnvironment>(x => x.ToAbsolute(It.IsAny<string>()) == "/umbraco" && x.ApplicationVirtualPath == string.Empty),
Mock.Of<IRuntimeState>(x => x.Level == RuntimeLevel.Run))));
var connectionStrings = new ConnectionStrings();
fixture.Customize<ConnectionStrings>(x => x.FromFactory(() => connectionStrings));
var configConnectionString = new ConfigConnectionString("ss",
"Data Source=(localdb)\\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\\Umbraco.mdf;Integrated Security=True");
fixture.Customize<ConfigConnectionString>(x => x.FromFactory(() => configConnectionString));
var httpContextAccessor = new HttpContextAccessor { HttpContext = new DefaultHttpContext() };
fixture.Customize<HttpContext>(x => x.FromFactory(() => httpContextAccessor.HttpContext));
fixture.Customize<IHttpContextAccessor>(x => x.FromFactory(() => httpContextAccessor));
fixture.Customize<WebRoutingSettings>(x => x.With(settings => settings.UmbracoApplicationUrl, "http://localhost:5000"));
fixture.Behaviors.Add(new OmitOnRecursionBehavior());
}
}
}

433
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs
View File

@@ -1,266 +1,167 @@
// using System;
// using System.Collections.Generic;
// using System.Diagnostics;
// using System.Linq;
// using AutoFixture.NUnit3;
// using CSharpTest.Net.Interfaces;
// using Moq;
// using NUnit.Framework;
// using Umbraco.Cms.Core.Events;
// using Umbraco.Cms.Core.Models;
// using Umbraco.Cms.Core.Scoping;
// using Umbraco.Cms.Core.Services;
// using Umbraco.Cms.Core.Services.Implement;
// using Umbraco.Cms.Tests.UnitTests.AutoFixture;
// using Umbraco.Core.Composing;
// using Umbraco.Core.Events;
// using Umbraco.Core.Models;
// using Umbraco.Core.Persistence.Repositories;
// using Umbraco.Core.Scoping;
// using Umbraco.Core.Services;
// using Umbraco.Core.Services.Implement;
// using Umbraco.Tests.Testing;
//
// namespace Umbraco.Tests.Services
// {
// /// <remarks>
// /// v9 -> Tests.UnitTests
// /// Sut here is ContentService, but in v9 should be a new class
// /// </remarks>
// [TestFixture]
// public class ContentVersionCleanupServiceTest
// {
//
//
// /// <remarks>
// /// For v9 this just needs a rewrite, no static events, no service location etc
// /// </remarks>
// [Test, AutoMoqData]
// public void PerformContentVersionCleanup_Always_RespectsDeleteRevisionsCancellation(
// [Frozen] Mock<IScope> scope,
// Mock<IDocumentVersionRepository> documentVersionRepository,
// List<TestHistoricContentVersionMeta> someHistoricVersions,
// DateTime aDateTime,
// ContentService sut)
// {
// factory.Setup(x => x.GetInstance(typeof(IDocumentVersionRepository)))
// .Returns(documentVersionRepository.Object);
//
// factory.Setup(x => x.GetInstance(typeof(IContentVersionCleanupPolicy)))
// .Returns(new EchoingCleanupPolicyStub());
//
// documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
// .Returns(someHistoricVersions);
//
// scope.Setup(x => x.Events).Returns(new PassThroughEventDispatcher());
//
// // Wire up service locator
// Current.Factory = factory.Object;
//
// void OnDeletingVersions(IContentService sender, DeleteRevisionsEventArgs args) => args.Cancel = true;
//
// ContentService.DeletingVersions += OnDeletingVersions;
//
// // # Act
// var report = sut.PerformContentVersionCleanup(aDateTime);
//
// ContentService.DeletingVersions -= OnDeletingVersions;
//
// Assert.AreEqual(0, report.Count);
// }
//
// /// <remarks>
// /// For v9 this just needs a rewrite, no static events, no service location etc
// /// </remarks>
// [Test, AutoMoqData]
// public void PerformContentVersionCleanup_Always_FiresDeletedVersionsForEachDeletedVersion(
// [Frozen] Mock<IFactory> factory,
// [Frozen] Mock<IScope> scope,
// Mock<IDocumentVersionRepository> documentVersionRepository,
// List<TestHistoricContentVersionMeta> someHistoricVersions,
// DateTime aDateTime,
// ContentService sut)
// {
// factory.Setup(x => x.GetInstance(typeof(IDocumentVersionRepository)))
// .Returns(documentVersionRepository.Object);
//
// factory.Setup(x => x.GetInstance(typeof(IContentVersionCleanupPolicy)))
// .Returns(new EchoingCleanupPolicyStub());
//
// documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
// .Returns(someHistoricVersions);
//
// scope.Setup(x => x.Events).Returns(new PassThroughEventDispatcher());
//
// // Wire up service locator
// Current.Factory = factory.Object;
//
// // v9 can Mock + Verify
// var deletedAccordingToEvents = 0;
// void OnDeletedVersions(IContentService sender, DeleteRevisionsEventArgs args) => deletedAccordingToEvents++;
//
// ContentService.DeletedVersions += OnDeletedVersions;
//
// // # Act
// sut.PerformContentVersionCleanup(aDateTime);
//
// ContentService.DeletedVersions -= OnDeletedVersions;
//
// Assert.Multiple(() =>
// {
// Assert.Greater(deletedAccordingToEvents, 0);
// Assert.AreEqual(someHistoricVersions.Count, deletedAccordingToEvents);
// });
// }
//
// /// <remarks>
// /// For v9 this just needs a rewrite, no static events, no service location etc
// /// </remarks>
// [Test, AutoMoqData]
// public void PerformContentVersionCleanup_Always_ReturnsReportOfDeletedItems(
// [Frozen] Mock<IFactory> factory,
// [Frozen] Mock<IScope> scope,
// Mock<IDocumentVersionRepository> documentVersionRepository,
// List<TestHistoricContentVersionMeta> someHistoricVersions,
// DateTime aDateTime,
// ContentService sut)
// {
// factory.Setup(x => x.GetInstance(typeof(IDocumentVersionRepository)))
// .Returns(documentVersionRepository.Object);
//
// factory.Setup(x => x.GetInstance(typeof(IContentVersionCleanupPolicy)))
// .Returns(new EchoingCleanupPolicyStub());
//
// documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
// .Returns(someHistoricVersions);
//
// scope.Setup(x => x.Events).Returns(new PassThroughEventDispatcher());
//
// // Wire up service locator
// Current.Factory = factory.Object;
//
// // # Act
// var report = sut.PerformContentVersionCleanup(aDateTime);
//
// Assert.Multiple(() =>
// {
// Assert.Greater(report.Count, 0);
// Assert.AreEqual(someHistoricVersions.Count, report.Count);
// });
// }
//
// /// <remarks>
// /// For v9 this just needs a rewrite, no static events, no service location etc
// /// </remarks>
// [Test, AutoMoqData]
// public void PerformContentVersionCleanup_Always_AdheresToCleanupPolicy(
// [Frozen] Mock<IFactory> factory,
// [Frozen] Mock<IScope> scope,
// Mock<IDocumentVersionRepository> documentVersionRepository,
// Mock<IContentVersionCleanupPolicy> cleanupPolicy,
// List<TestHistoricContentVersionMeta> someHistoricVersions,
// DateTime aDateTime,
// ContentService sut)
// {
// factory.Setup(x => x.GetInstance(typeof(IDocumentVersionRepository)))
// .Returns(documentVersionRepository.Object);
//
// factory.Setup(x => x.GetInstance(typeof(IContentVersionCleanupPolicy)))
// .Returns(cleanupPolicy.Object);
//
// documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
// .Returns(someHistoricVersions);
//
// scope.Setup(x => x.Events).Returns(new PassThroughEventDispatcher());
//
// cleanupPolicy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<TestHistoricContentVersionMeta>>()))
// .Returns<DateTime, IEnumerable<TestHistoricContentVersionMeta>>((_, items) => items.Take(1));
//
// // Wire up service locator
// Current.Factory = factory.Object;
//
// // # Act
// var report = sut.PerformContentVersionCleanup(aDateTime);
//
// Debug.Assert(someHistoricVersions.Count > 1);
//
// Assert.Multiple(() =>
// {
// cleanupPolicy.Verify(x => x.Apply(aDateTime, someHistoricVersions), Times.Once);
// Assert.AreEqual(someHistoricVersions.First(), report.Single());
// });
// }
//
// /// <remarks>
// /// For v9 this just needs a rewrite, no static events, no service location etc
// /// </remarks>
// [Test, AutoMoqData]
// public void PerformContentVersionCleanup_HasVersionsToDelete_CallsDeleteOnRepositoryWithFilteredSet(
// [Frozen] Mock<IFactory> factory,
// [Frozen] Mock<IScope> scope,
// Mock<IDocumentVersionRepository> documentVersionRepository,
// Mock<IContentVersionCleanupPolicy> cleanupPolicy,
// List<TestHistoricContentVersionMeta> someHistoricVersions,
// DateTime aDateTime,
// ContentService sut)
// {
// factory.Setup(x => x.GetInstance(typeof(IDocumentVersionRepository)))
// .Returns(documentVersionRepository.Object);
//
// factory.Setup(x => x.GetInstance(typeof(IContentVersionCleanupPolicy)))
// .Returns(cleanupPolicy.Object);
//
// documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
// .Returns(someHistoricVersions);
//
// scope.Setup(x => x.Events).Returns(new PassThroughEventDispatcher());
//
// var filteredSet = someHistoricVersions.Take(1);
//
// cleanupPolicy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<TestHistoricContentVersionMeta>>()))
// .Returns<DateTime, IEnumerable<TestHistoricContentVersionMeta>>((_, items) => filteredSet);
//
// // Wire up service locator
// Current.Factory = factory.Object;
//
// // # Act
// var report = sut.PerformContentVersionCleanup(aDateTime);
//
// Debug.Assert(someHistoricVersions.Any());
//
// var expectedId = filteredSet.First().VersionId;
//
// documentVersionRepository.Verify(x => x.DeleteVersions(It.Is<IEnumerable<int>>(y => y.Single() == expectedId)), Times.Once);
// }
//
// class EchoingCleanupPolicyStub : IContentVersionCleanupPolicy
// {
// /// <summary>
// /// What goes in, must come out
// /// </summary>
// public EchoingCleanupPolicyStub() { }
//
// /* Note: Could just wire up a mock but its quite wordy.
// *
// * cleanupPolicy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<TestHistoricContentVersionMeta>>()))
// * .Returns<DateTime, IEnumerable<TestHistoricContentVersionMeta>>((date, items) => items);
// */
// public IEnumerable<HistoricContentVersionMeta> Apply(
// DateTime asAtDate,
// IEnumerable<HistoricContentVersionMeta> items
// ) => items;
// }
//
// /// <remarks>
// /// <para>NPoco &lt; 5 requires a parameter-less constructor but plays nice with get-only properties.</para>
// /// <para>Moq won't play nice with get-only properties, but doesn't require a parameter-less constructor.</para>
// ///
// /// <para>Inheritance solves this so that we get values for test data without a specimen builder</para>
// /// </remarks>
// public class TestHistoricContentVersionMeta : HistoricContentVersionMeta
// {
// public TestHistoricContentVersionMeta(int contentId, int contentTypeId, int versionId, DateTime versionDate)
// : base(contentId, contentTypeId, versionId, versionDate) { }
// }
// }
// }
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using AutoFixture.NUnit3;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core.Events;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Notifications;
using Umbraco.Cms.Core.Persistence.Repositories;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Services.Implement;
using Umbraco.Cms.Tests.UnitTests.AutoFixture;
namespace Umbraco.Tests.Services
{
[TestFixture]
internal class ContentVersionCleanupServiceTest
{
[Test]
[AutoMoqData]
public void PerformContentVersionCleanup_Always_RespectsDeleteRevisionsCancellation(
[Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
[Frozen] Mock<IContentVersionCleanupPolicy> policy,
[Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
List<HistoricContentVersionMeta> someHistoricVersions,
DateTime aDateTime,
ContentVersionService sut)
{
documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
.Returns(someHistoricVersions);
eventAggregator.Setup(x => x.PublishCancelable(It.IsAny<ContentDeletingVersionsNotification>()))
.Returns(true);
policy.Setup(x => x.Apply(aDateTime, someHistoricVersions))
.Returns(someHistoricVersions);
// # Act
IReadOnlyCollection<HistoricContentVersionMeta> report = sut.PerformContentVersionCleanup(aDateTime);
Assert.Multiple(() =>
{
eventAggregator.Verify(x => x.PublishCancelable(It.IsAny<ContentDeletingVersionsNotification>()), Times.Exactly(someHistoricVersions.Count));
Assert.AreEqual(0, report.Count);
});
}
[Test]
[AutoMoqData]
public void PerformContentVersionCleanup_Always_FiresDeletedVersionsForEachDeletedVersion(
[Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
[Frozen] Mock<IContentVersionCleanupPolicy> policy,
[Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
List<HistoricContentVersionMeta> someHistoricVersions,
DateTime aDateTime,
ContentVersionService sut)
{
documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
.Returns(someHistoricVersions);
eventAggregator
.Setup(x => x.PublishCancelable(It.IsAny<ICancelableNotification>()))
.Returns(false);
policy.Setup(x => x.Apply(aDateTime, someHistoricVersions))
.Returns(someHistoricVersions);
// # Act
sut.PerformContentVersionCleanup(aDateTime);
eventAggregator.Verify(x => x.Publish(It.IsAny<ContentDeletedVersionsNotification>()), Times.Exactly(someHistoricVersions.Count));
}
[Test, AutoMoqData]
public void PerformContentVersionCleanup_Always_ReturnsReportOfDeletedItems(
[Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
[Frozen] Mock<IContentVersionCleanupPolicy> policy,
[Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
List<HistoricContentVersionMeta> someHistoricVersions,
DateTime aDateTime,
ContentVersionService sut)
{
documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
.Returns(someHistoricVersions);
eventAggregator
.Setup(x => x.PublishCancelable(It.IsAny<ICancelableNotification>()))
.Returns(false);
// # Act
var report = sut.PerformContentVersionCleanup(aDateTime);
Assert.Multiple(() =>
{
Assert.Greater(report.Count, 0);
Assert.AreEqual(someHistoricVersions.Count, report.Count);
});
}
[Test, AutoMoqData]
public void PerformContentVersionCleanup_Always_AdheresToCleanupPolicy(
[Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
[Frozen] Mock<IContentVersionCleanupPolicy> policy,
[Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
List<HistoricContentVersionMeta> someHistoricVersions,
DateTime aDateTime,
ContentVersionService sut)
{
documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
.Returns(someHistoricVersions);
eventAggregator
.Setup(x => x.PublishCancelable(It.IsAny<ICancelableNotification>()))
.Returns(false);
policy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<HistoricContentVersionMeta>>()))
.Returns<DateTime, IEnumerable<HistoricContentVersionMeta>>((_, items) => items.Take(1));
// # Act
var report = sut.PerformContentVersionCleanup(aDateTime);
Debug.Assert(someHistoricVersions.Count > 1);
Assert.Multiple(() =>
{
policy.Verify(x => x.Apply(aDateTime, someHistoricVersions), Times.Once);
Assert.AreEqual(someHistoricVersions.First(), report.Single());
});
}
/// <remarks>
/// For v9 this just needs a rewrite, no static events, no service location etc
/// </remarks>
[Test, AutoMoqData]
public void PerformContentVersionCleanup_HasVersionsToDelete_CallsDeleteOnRepositoryWithFilteredSet(
[Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
[Frozen] Mock<IContentVersionCleanupPolicy> policy,
[Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
List<HistoricContentVersionMeta> someHistoricVersions,
DateTime aDateTime,
ContentVersionService sut)
{
documentVersionRepository.Setup(x => x.GetDocumentVersionsEligibleForCleanup())
.Returns(someHistoricVersions);
eventAggregator
.Setup(x => x.PublishCancelable(It.IsAny<ICancelableNotification>()))
.Returns(false);
var filteredSet = someHistoricVersions.Take(1);
policy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<HistoricContentVersionMeta>>()))
.Returns<DateTime, IEnumerable<HistoricContentVersionMeta>>((_, items) => filteredSet);
// # Act
var report = sut.PerformContentVersionCleanup(aDateTime);
Debug.Assert(someHistoricVersions.Any());
var expectedId = filteredSet.First().VersionId;
documentVersionRepository.Verify(x => x.DeleteVersions(It.Is<IEnumerable<int>>(y => y.Single() == expectedId)), Times.Once);
}
}
}

15
tests/Umbraco.Tests.UnitTests/Umbraco.Web.BackOffice/Controllers/MemberControllerUnitTests.cs
View File

@@ -121,6 +121,9 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.BackOffice.Controllers
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.ValidatePasswordAsync(It.IsAny<string>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.GetRolesAsync(It.IsAny<MemberIdentityUser>()))
.ReturnsAsync(() => Array.Empty<string>());
Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
Mock.Get(backOfficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(backOfficeSecurity);
Mock.Get(memberService).SetupSequence(
@@ -162,6 +165,9 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.BackOffice.Controllers
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.ValidatePasswordAsync(It.IsAny<string>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.GetRolesAsync(It.IsAny<MemberIdentityUser>()))
.ReturnsAsync(() => Array.Empty<string>());
Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
Mock.Get(backOfficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(backOfficeSecurity);
Mock.Get(memberService).SetupSequence(
@@ -209,6 +215,9 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.BackOffice.Controllers
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.UpdateAsync(It.IsAny<MemberIdentityUser>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.GetRolesAsync(It.IsAny<MemberIdentityUser>()))
.ReturnsAsync(() => Array.Empty<string>());
Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
Mock.Get(globalSettings);
@@ -392,6 +401,10 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.BackOffice.Controllers
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.AddToRolesAsync(It.IsAny<MemberIdentityUser>(), It.IsAny<IEnumerable<string>>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.GetRolesAsync(It.IsAny<MemberIdentityUser>()))
.ReturnsAsync(() => Array.Empty<string>());
Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
Mock.Get(backOfficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(backOfficeSecurity);
Mock.Get(memberService).Setup(x => x.GetByUsername(It.IsAny<string>())).Returns(() => member);
@@ -416,6 +429,8 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.BackOffice.Controllers
.Verify(u => u.GetRolesAsync(membersIdentityUser));
Mock.Get(umbracoMembersUserManager)
.Verify(u => u.AddToRolesAsync(membersIdentityUser, new[] { roleName }));
Mock.Get(umbracoMembersUserManager)
.Verify(x => x.GetRolesAsync(It.IsAny<MemberIdentityUser>()));
Mock.Get(memberService)
.Verify(m => m.Save(It.IsAny<Member>()));
AssertMemberDisplayPropertiesAreEqual(memberDisplay, result.Value);