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

Rename PluginConfiguration to PackageManifest + a little more legacy manifest renaming

Browse Source
This commit is contained in:
kjac
2023-02-15 15:17:50 +01:00
parent d2ed03a5d8
commit e0c396afd6
26 changed files with 248 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/Umbraco.Cms.Api.Management/Controllers/Package/AllPackageManifestsController.cs Normal file
View File

@@ -0,0 +1,34 @@
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Umbraco.Cms.Api.Common.ViewModels.Pagination;
using Umbraco.Cms.Api.Management.ViewModels.Package;
using Umbraco.Cms.Core.Manifest;
using Umbraco.Cms.Core.Mapping;
namespace Umbraco.Cms.Api.Management.Controllers.Package;
public class AllPackageManifestsController : PackageControllerBase
{
private readonly IPackageManifestService _packageManifestService;
private readonly IUmbracoMapper _umbracoMapper;
public AllPackageManifestsController(IPackageManifestService packageManifestService, IUmbracoMapper umbracoMapper)
{
_packageManifestService = packageManifestService;
_umbracoMapper = umbracoMapper;
}
[HttpGet("manifest")]
[MapToApiVersion("1.0")]
[ProducesResponseType(typeof(PagedViewModel<PackageManifestViewModel>), StatusCodes.Status200OK)]
public async Task<ActionResult<PagedViewModel<PackageManifestViewModel>>> AllPackageManifests(int skip = 0, int take = 100)
{
PackageManifest[] packageManifests = (await _packageManifestService.GetPackageManifestsAsync()).ToArray();
return Ok(
new PagedViewModel<PackageManifestViewModel>
{
Items = _umbracoMapper.MapEnumerable<PackageManifest, PackageManifestViewModel>(packageManifests.Skip(skip).Take(take)),
Total = packageManifests.Length
});
}
}

34
src/Umbraco.Cms.Api.Management/Controllers/Package/AllPluginsController.cs
View File

@@ -1,34 +0,0 @@
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Umbraco.Cms.Api.Common.ViewModels.Pagination;
using Umbraco.Cms.Api.Management.ViewModels.Package;
using Umbraco.Cms.Core.Plugin;
using Umbraco.Cms.Core.Mapping;
namespace Umbraco.Cms.Api.Management.Controllers.Package;
public class AllPluginsController : PackageControllerBase
{
private readonly IPluginConfigurationService _pluginConfigurationService;
private readonly IUmbracoMapper _umbracoMapper;
public AllPluginsController(IPluginConfigurationService pluginConfigurationService, IUmbracoMapper umbracoMapper)
{
_pluginConfigurationService = pluginConfigurationService;
_umbracoMapper = umbracoMapper;
}
[HttpGet("plugins")]
[MapToApiVersion("1.0")]
[ProducesResponseType(typeof(PagedViewModel<PluginConfigurationViewModel>), StatusCodes.Status200OK)]
public async Task<ActionResult<PagedViewModel<PluginConfigurationViewModel>>> AllPlugins(int skip = 0, int take = 100)
{
PluginConfiguration[] pluginConfigurations = (await _pluginConfigurationService.GetPluginConfigurationsAsync()).ToArray();
return Ok(
new PagedViewModel<PluginConfigurationViewModel>
{
Items = _umbracoMapper.MapEnumerable<PluginConfiguration, PluginConfigurationViewModel>(pluginConfigurations.Skip(skip).Take(take)),
Total = pluginConfigurations.Length
});
}
}

2
src/Umbraco.Cms.Api.Management/DependencyInjection/PackageBuilderExtensions.cs
View File

@@ -8,7 +8,7 @@ internal static class PackageBuilderExtensions
{
internal static IUmbracoBuilder AddPackages(this IUmbracoBuilder builder)
{
builder.WithCollectionBuilder<MapDefinitionCollectionBuilder>().Add<PluginConfigurationViewModelMapDefinition>();
builder.WithCollectionBuilder<MapDefinitionCollectionBuilder>().Add<PackageManifestViewModelMapDefinition>();
return builder;
}

7
src/Umbraco.Cms.Api.Management/Mapping/Package/PluginConfigurationViewModelMapDefinition.cs → src/Umbraco.Cms.Api.Management/Mapping/Package/PackageManifestViewModelMapDefinition.cs
View File

@@ -1,17 +1,16 @@
using Umbraco.Cms.Api.Management.ViewModels.Package;
using Umbraco.Cms.Core.Plugin;
using Umbraco.Cms.Core.Manifest;
using Umbraco.Cms.Core.Mapping;
namespace Umbraco.Cms.Api.Management.Mapping.Package;
public class PluginConfigurationViewModelMapDefinition : IMapDefinition
public class PackageManifestViewModelMapDefinition : IMapDefinition
{
public void DefineMaps(IUmbracoMapper mapper)
=> mapper.Define<PluginConfiguration, PluginConfigurationViewModel>((_, _) => new PluginConfigurationViewModel(), Map);
=> mapper.Define<PackageManifest, PackageManifestViewModel>((_, _) => new PackageManifestViewModel(), Map);
// Umbraco.Code.MapAll
private static void Map(PluginConfiguration source, PluginConfigurationViewModel target, MapperContext context)
private static void Map(PackageManifest source, PackageManifestViewModel target, MapperContext context)
{
target.Name = source.Name;
target.Version = source.Version;

2
src/Umbraco.Cms.Api.Management/ViewModels/Package/PluginConfigurationViewModel.cs → src/Umbraco.Cms.Api.Management/ViewModels/Package/PackageManifestViewModel.cs
View File

@@ -1,6 +1,6 @@
namespace Umbraco.Cms.Api.Management.ViewModels.Package;
public class PluginConfigurationViewModel
public class PackageManifestViewModel
{
public string Name { get; set; } = string.Empty;

2
src/Umbraco.Core/IO/IManifestFileProviderFactory.cs → src/Umbraco.Core/IO/ILegacyPackageManifestFileProviderFactory.cs
View File

@@ -5,6 +5,6 @@ namespace Umbraco.Cms.Core.IO;
/// <summary>
/// Factory for creating <see cref="IFileProvider" /> instances for providing the package.manifest file.
/// </summary>
public interface IManifestFileProviderFactory : IFileProviderFactory
public interface ILegacyPackageManifestFileProviderFactory : IFileProviderFactory
{
}

2
src/Umbraco.Core/IO/IPluginConfigurationFileProviderFactory.cs → src/Umbraco.Core/IO/IPackageManifestFileProviderFactory.cs
View File

@@ -5,6 +5,6 @@ namespace Umbraco.Cms.Core.IO;
/// <summary>
/// Factory for creating <see cref="IFileProvider" /> instances for providing the umbraco-package.json file.
/// </summary>
public interface IPluginConfigurationFileProviderFactory : IFileProviderFactory
public interface IPackageManifestFileProviderFactory : IFileProviderFactory
{
}

6
src/Umbraco.Core/Manifest/IPackageManifestService.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace Umbraco.Cms.Core.Manifest;
public interface IPackageManifestService
{
Task<IEnumerable<PackageManifest>> GetPackageManifestsAsync();
}

4
src/Umbraco.Core/Plugin/PluginConfiguration.cs → src/Umbraco.Core/Manifest/PackageManifest.cs
View File

@@ -1,6 +1,6 @@
namespace Umbraco.Cms.Core.Plugin;
namespace Umbraco.Cms.Core.Manifest;
public class PluginConfiguration
public class PackageManifest
{
public required string Name { get; set; }

6
src/Umbraco.Core/Plugin/IPluginConfigurationService.cs
View File

@@ -1,6 +0,0 @@
namespace Umbraco.Cms.Core.Plugin;
public interface IPluginConfigurationService
{
Task<IEnumerable<PluginConfiguration>> GetPluginConfigurationsAsync();
}

15
src/Umbraco.Core/Telemetry/TelemetryService.cs
View File

@@ -4,7 +4,6 @@
using Microsoft.Extensions.DependencyInjection;
using Umbraco.Cms.Core.Configuration;
using Umbraco.Cms.Core.DependencyInjection;
using Umbraco.Cms.Core.Plugin;
using Umbraco.Cms.Core.Manifest;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Services;
@@ -20,7 +19,7 @@ internal class TelemetryService : ITelemetryService
private readonly ISiteIdentifierService _siteIdentifierService;
private readonly IUmbracoVersion _umbracoVersion;
private readonly IUsageInformationService _usageInformationService;
private readonly IPluginConfigurationService _pluginConfigurationService;
private readonly IPackageManifestService _packageManifestService;
[Obsolete("Please use the constructor that does not take an IManifestParser. Will be removed in V15.")]
public TelemetryService(
@@ -35,7 +34,7 @@ internal class TelemetryService : ITelemetryService
siteIdentifierService,
usageInformationService,
metricsConsentService,
StaticServiceProvider.Instance.GetRequiredService<IPluginConfigurationService>())
StaticServiceProvider.Instance.GetRequiredService<IPackageManifestService>())
{
}
@@ -46,13 +45,13 @@ internal class TelemetryService : ITelemetryService
ISiteIdentifierService siteIdentifierService,
IUsageInformationService usageInformationService,
IMetricsConsentService metricsConsentService,
IPluginConfigurationService pluginConfigurationService)
IPackageManifestService packageManifestService)
: this(
umbracoVersion,
siteIdentifierService,
usageInformationService,
metricsConsentService,
pluginConfigurationService)
packageManifestService)
{
}
@@ -64,13 +63,13 @@ internal class TelemetryService : ITelemetryService
ISiteIdentifierService siteIdentifierService,
IUsageInformationService usageInformationService,
IMetricsConsentService metricsConsentService,
IPluginConfigurationService pluginConfigurationService)
IPackageManifestService packageManifestService)
{
_umbracoVersion = umbracoVersion;
_siteIdentifierService = siteIdentifierService;
_usageInformationService = usageInformationService;
_metricsConsentService = metricsConsentService;
_pluginConfigurationService = pluginConfigurationService;
_packageManifestService = packageManifestService;
}
[Obsolete("Please use GetTelemetryReportDataAsync. Will be removed in V15.")]
@@ -108,7 +107,7 @@ internal class TelemetryService : ITelemetryService
return null;
}
IEnumerable<PluginConfiguration> manifests = await _pluginConfigurationService.GetPluginConfigurationsAsync();
IEnumerable<PackageManifest> manifests = await _packageManifestService.GetPackageManifestsAsync();
return manifests
.Where(manifest => manifest.AllowTelemetry)

7
src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.CoreServices.cs
View File

@@ -10,7 +10,6 @@ using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.DependencyInjection;
using Umbraco.Cms.Core.DistributedLocking;
using Umbraco.Cms.Core.Events;
using Umbraco.Cms.Core.Plugin;
using Umbraco.Cms.Core.Handlers;
using Umbraco.Cms.Core.HealthChecks.NotificationMethods;
using Umbraco.Cms.Core.Hosting;
@@ -40,11 +39,11 @@ using Umbraco.Cms.Core.Trees;
using Umbraco.Cms.Core.Web;
using Umbraco.Cms.Infrastructure.DistributedLocking;
using Umbraco.Cms.Infrastructure.Examine;
using Umbraco.Cms.Infrastructure.Plugin;
using Umbraco.Cms.Infrastructure.HealthChecks;
using Umbraco.Cms.Infrastructure.HostedServices;
using Umbraco.Cms.Infrastructure.Install;
using Umbraco.Cms.Infrastructure.Mail;
using Umbraco.Cms.Infrastructure.Manifest;
using Umbraco.Cms.Infrastructure.Migrations;
using Umbraco.Cms.Infrastructure.Migrations.Install;
using Umbraco.Cms.Infrastructure.Migrations.PostMigrations;
@@ -129,8 +128,8 @@ public static partial class UmbracoBuilderExtensions
// register manifest parser, will be injected in collection builders where needed
builder.Services.AddSingleton<ILegacyManifestParser, LegacyManifestParser>();
builder.Services.AddSingleton<IPluginConfigurationReader, PluginConfigurationReader>();
builder.Services.AddSingleton<IPluginConfigurationService, PluginConfigurationService>();
builder.Services.AddSingleton<IPackageManifestReader, PackageManifestReader>();
builder.Services.AddSingleton<IPackageManifestService, PackageManifestService>();
// register the manifest filter collection builder (collection is empty by default)
builder.ManifestFilters();

8
src/Umbraco.Infrastructure/Manifest/IPackageManifestReader.cs Normal file
View File

@@ -0,0 +1,8 @@
using Umbraco.Cms.Core.Manifest;
namespace Umbraco.Cms.Infrastructure.Manifest;
public interface IPackageManifestReader
{
Task<IEnumerable<PackageManifest>> ReadPackageManifestsAsync();
}

10
src/Umbraco.Infrastructure/Manifest/LegacyManifestParser.cs
View File

@@ -25,7 +25,7 @@ public class LegacyManifestParser : ILegacyManifestParser
private readonly IAppPolicyCache _cache;
private readonly IDataValueEditorFactory _dataValueEditorFactory;
private readonly IManifestFileProviderFactory _manifestFileProviderFactory;
private readonly ILegacyPackageManifestFileProviderFactory _legacyPackageManifestFileProviderFactory;
private readonly LegacyManifestFilterCollection _filters;
private readonly IHostingEnvironment _hostingEnvironment;
@@ -52,7 +52,7 @@ public class LegacyManifestParser : ILegacyManifestParser
ILocalizedTextService localizedTextService,
IShortStringHelper shortStringHelper,
IDataValueEditorFactory dataValueEditorFactory,
IManifestFileProviderFactory manifestFileProviderFactory)
ILegacyPackageManifestFileProviderFactory legacyPackageManifestFileProviderFactory)
{
if (appCaches == null)
{
@@ -70,7 +70,7 @@ public class LegacyManifestParser : ILegacyManifestParser
_localizedTextService = localizedTextService;
_shortStringHelper = shortStringHelper;
_dataValueEditorFactory = dataValueEditorFactory;
_manifestFileProviderFactory = manifestFileProviderFactory;
_legacyPackageManifestFileProviderFactory = legacyPackageManifestFileProviderFactory;
}
[Obsolete("Use other ctor - Will be removed in Umbraco 13")]
@@ -96,7 +96,7 @@ public class LegacyManifestParser : ILegacyManifestParser
localizedTextService,
shortStringHelper,
dataValueEditorFactory,
StaticServiceProvider.Instance.GetRequiredService<IManifestFileProviderFactory>())
StaticServiceProvider.Instance.GetRequiredService<ILegacyPackageManifestFileProviderFactory>())
{
}
@@ -123,7 +123,7 @@ public class LegacyManifestParser : ILegacyManifestParser
public IEnumerable<LegacyPackageManifest> GetManifests()
{
var manifests = new List<LegacyPackageManifest>();
IFileProvider? manifestFileProvider = _manifestFileProviderFactory.Create();
IFileProvider? manifestFileProvider = _legacyPackageManifestFileProviderFactory.Create();
if (manifestFileProvider is null)
{

44
src/Umbraco.Infrastructure/Plugin/PluginConfigurationReader.cs → src/Umbraco.Infrastructure/Manifest/PackageManifestReader.cs
View File

@@ -2,43 +2,43 @@
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Logging;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Plugin;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Manifest;
using Umbraco.Cms.Core.Routing;
using Umbraco.Cms.Core.Serialization;
using Umbraco.Extensions;
namespace Umbraco.Cms.Infrastructure.Plugin;
namespace Umbraco.Cms.Infrastructure.Manifest;
internal sealed class PluginConfigurationReader : IPluginConfigurationReader
internal sealed class PackageManifestReader : IPackageManifestReader
{
private readonly IPluginConfigurationFileProviderFactory _pluginConfigurationFileProviderFactory;
private readonly IPackageManifestFileProviderFactory _packageManifestFileProviderFactory;
private readonly IJsonSerializer _jsonSerializer;
private readonly ILogger<PluginConfigurationReader> _logger;
private readonly ILogger<PackageManifestReader> _logger;
public PluginConfigurationReader(
IPluginConfigurationFileProviderFactory pluginConfigurationFileProviderFactory,
public PackageManifestReader(
IPackageManifestFileProviderFactory packageManifestFileProviderFactory,
IJsonSerializer jsonSerializer,
ILogger<PluginConfigurationReader> logger)
ILogger<PackageManifestReader> logger)
{
_pluginConfigurationFileProviderFactory = pluginConfigurationFileProviderFactory;
_packageManifestFileProviderFactory = packageManifestFileProviderFactory;
_jsonSerializer = jsonSerializer;
_logger = logger;
}
public async Task<IEnumerable<PluginConfiguration>> ReadPluginConfigurationsAsync()
public async Task<IEnumerable<PackageManifest>> ReadPackageManifestsAsync()
{
IFileProvider? fileProvider = _pluginConfigurationFileProviderFactory.Create();
IFileProvider? fileProvider = _packageManifestFileProviderFactory.Create();
if (fileProvider is null)
{
throw new ArgumentNullException(nameof(fileProvider));
}
IFileInfo[] files = GetAllPluginConfigurationFiles(fileProvider, Constants.SystemDirectories.AppPlugins).ToArray();
return await ParsePluginConfigurationFiles(files);
IFileInfo[] files = GetAllPackageManifestFiles(fileProvider, Constants.SystemDirectories.AppPlugins).ToArray();
return await ParsePackageManifestFiles(files);
}
private static IEnumerable<IFileInfo> GetAllPluginConfigurationFiles(IFileProvider fileProvider, string path)
private static IEnumerable<IFileInfo> GetAllPackageManifestFiles(IFileProvider fileProvider, string path)
{
const string extensionFileName = "umbraco-package.json";
foreach (IFileInfo fileInfo in fileProvider.GetDirectoryContents(path))
@@ -48,7 +48,7 @@ internal sealed class PluginConfigurationReader : IPluginConfigurationReader
var virtualPath = WebPath.Combine(path, fileInfo.Name);
// find all extension package configuration files recursively
foreach (IFileInfo nested in GetAllPluginConfigurationFiles(fileProvider, virtualPath))
foreach (IFileInfo nested in GetAllPackageManifestFiles(fileProvider, virtualPath))
{
yield return nested;
}
@@ -60,9 +60,9 @@ internal sealed class PluginConfigurationReader : IPluginConfigurationReader
}
}
private async Task<IEnumerable<PluginConfiguration>> ParsePluginConfigurationFiles(IFileInfo[] files)
private async Task<IEnumerable<PackageManifest>> ParsePackageManifestFiles(IFileInfo[] files)
{
var pluginConfigurations = new List<PluginConfiguration>();
var packageManifests = new List<PackageManifest>();
foreach (IFileInfo fileInfo in files)
{
string fileContent;
@@ -81,18 +81,18 @@ internal sealed class PluginConfigurationReader : IPluginConfigurationReader
try
{
PluginConfiguration? pluginConfiguration = _jsonSerializer.Deserialize<PluginConfiguration>(fileContent);
if (pluginConfiguration != null)
PackageManifest? packageManifest = _jsonSerializer.Deserialize<PackageManifest>(fileContent);
if (packageManifest != null)
{
pluginConfigurations.Add(pluginConfiguration);
packageManifests.Add(packageManifest);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Unable to load plugin configuration file: {FileName}", fileInfo.Name);
_logger.LogError(ex, "Unable to load package manifest file: {FileName}", fileInfo.Name);
}
}
return pluginConfigurations;
return packageManifests;
}
}

24
src/Umbraco.Infrastructure/Manifest/PackageManifestService.cs Normal file
View File

@@ -0,0 +1,24 @@
using Umbraco.Cms.Core.Cache;
using Umbraco.Cms.Core.Manifest;
using Umbraco.Extensions;
namespace Umbraco.Cms.Infrastructure.Manifest;
internal sealed class PackageManifestService : IPackageManifestService
{
private readonly IPackageManifestReader _packageManifestReader;
private readonly IAppPolicyCache _cache;
public PackageManifestService(IPackageManifestReader packageManifestReader, AppCaches appCaches)
{
_packageManifestReader = packageManifestReader;
_cache = appCaches.RuntimeCache;
}
public async Task<IEnumerable<PackageManifest>> GetPackageManifestsAsync()
=> await _cache.GetCacheItemAsync(
$"{nameof(PackageManifestService)}-PackageManifests",
async () => await _packageManifestReader.ReadPackageManifestsAsync(),
TimeSpan.FromMinutes(10))
?? Array.Empty<PackageManifest>();
}

8
src/Umbraco.Infrastructure/Plugin/IPluginConfigurationReader.cs
View File

@@ -1,8 +0,0 @@
using Umbraco.Cms.Core.Plugin;
namespace Umbraco.Cms.Infrastructure.Plugin;
public interface IPluginConfigurationReader
{
Task<IEnumerable<PluginConfiguration>> ReadPluginConfigurationsAsync();
}

24
src/Umbraco.Infrastructure/Plugin/PluginConfigurationService.cs
View File

@@ -1,24 +0,0 @@
using Umbraco.Cms.Core.Cache;
using Umbraco.Cms.Core.Plugin;
using Umbraco.Extensions;
namespace Umbraco.Cms.Infrastructure.Plugin;
internal sealed class PluginConfigurationService : IPluginConfigurationService
{
private readonly IPluginConfigurationReader _pluginConfigurationReader;
private readonly IAppPolicyCache _cache;
public PluginConfigurationService(IPluginConfigurationReader pluginConfigurationReader, AppCaches appCaches)
{
_pluginConfigurationReader = pluginConfigurationReader;
_cache = appCaches.RuntimeCache;
}
public async Task<IEnumerable<PluginConfiguration>> GetPluginConfigurationsAsync()
=> await _cache.GetCacheItemAsync(
$"{nameof(PluginConfigurationService)}-PluginConfigurations",
async () => await _pluginConfigurationReader.ReadPluginConfigurationsAsync(),
TimeSpan.FromMinutes(10))
?? Array.Empty<PluginConfiguration>();
}

4
src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilderExtensions.cs
View File

@@ -149,9 +149,9 @@ public static partial class UmbracoBuilderExtensions
// WebRootFileProviderFactory is just a wrapper around the IWebHostEnvironment.WebRootFileProvider,
// therefore no need to register it as singleton
builder.Services.AddSingleton<IManifestFileProviderFactory, ContentAndWebRootFileProviderFactory>();
builder.Services.AddSingleton<ILegacyPackageManifestFileProviderFactory, ContentAndWebRootFileProviderFactory>();
builder.Services.AddSingleton<IGridEditorsConfigFileProviderFactory, WebRootFileProviderFactory>();
builder.Services.AddSingleton<IPluginConfigurationFileProviderFactory, ContentAndWebRootFileProviderFactory>();
builder.Services.AddSingleton<IPackageManifestFileProviderFactory, ContentAndWebRootFileProviderFactory>();
// Must be added here because DbProviderFactories is netstandard 2.1 so cannot exist in Infra for now
builder.Services.AddSingleton<IDbProviderFactoryCreator>(factory => new DbProviderFactoryCreator(

2
src/Umbraco.Web.Common/FileProviders/ContentAndWebRootFileProviderFactory.cs
View File

@@ -4,7 +4,7 @@ using Umbraco.Cms.Core.IO;
namespace Umbraco.Cms.Web.Common.FileProviders;
public class ContentAndWebRootFileProviderFactory : IManifestFileProviderFactory, IPluginConfigurationFileProviderFactory
public class ContentAndWebRootFileProviderFactory : ILegacyPackageManifestFileProviderFactory, IPackageManifestFileProviderFactory
{
private readonly IWebHostEnvironment _webHostEnvironment;

2
src/Umbraco.Web.Common/FileProviders/WebRootFileProviderFactory.cs
View File

@@ -4,7 +4,7 @@ using Umbraco.Cms.Core.IO;
namespace Umbraco.Cms.Web.Common.FileProviders;
public class WebRootFileProviderFactory : IManifestFileProviderFactory, IGridEditorsConfigFileProviderFactory
public class WebRootFileProviderFactory : ILegacyPackageManifestFileProviderFactory, IGridEditorsConfigFileProviderFactory
{
private readonly IWebHostEnvironment _webHostEnvironment;

2
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Manifest/LegacyManifestParserTests.cs
View File

@@ -48,7 +48,7 @@ public class LegacyManifestParserTests
Mock.Of<ILocalizedTextService>(),
Mock.Of<IShortStringHelper>(),
Mock.Of<IDataValueEditorFactory>(),
Mock.Of<IManifestFileProviderFactory>());
Mock.Of<ILegacyPackageManifestFileProviderFactory>());
}
private LegacyManifestParser _parser;

92
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Plugin/PluginConfigurationReaderTests.cs → tests/Umbraco.Tests.UnitTests/Umbraco.Core/Manifest/PackageManifestReaderTests.cs
View File

@@ -6,17 +6,17 @@ using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Infrastructure.Plugin;
using Umbraco.Cms.Infrastructure.Manifest;
using Umbraco.Cms.Infrastructure.Serialization;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Plugin;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Manifest;
[TestFixture]
public class PluginConfigurationReaderTests
public class PackageManifestReaderTests
{
private IPluginConfigurationReader _reader;
private IPackageManifestReader _reader;
private Mock<IDirectoryContents> _rootDirectoryContentsMock;
private Mock<ILogger<PluginConfigurationReader>> _loggerMock;
private Mock<ILogger<PackageManifestReader>> _loggerMock;
private Mock<IFileProvider> _fileProviderMock;
[SetUp]
@@ -27,82 +27,82 @@ public class PluginConfigurationReaderTests
_fileProviderMock
.Setup(m => m.GetDirectoryContents(Constants.SystemDirectories.AppPlugins))
.Returns(_rootDirectoryContentsMock.Object);
var fileProviderFactoryMock = new Mock<IPluginConfigurationFileProviderFactory>();
var fileProviderFactoryMock = new Mock<IPackageManifestFileProviderFactory>();
fileProviderFactoryMock.Setup(m => m.Create()).Returns(_fileProviderMock.Object);
_loggerMock = new Mock<ILogger<PluginConfigurationReader>>();
_reader = new PluginConfigurationReader(fileProviderFactoryMock.Object, new SystemTextJsonSerializer(), _loggerMock.Object);
_loggerMock = new Mock<ILogger<PackageManifestReader>>();
_reader = new PackageManifestReader(fileProviderFactoryMock.Object, new SystemTextJsonSerializer(), _loggerMock.Object);
}
[Test]
public async Task Can_Read_PluginConfigurations_At_Root()
public async Task Can_Read_PackageManifests_At_Root()
{
_rootDirectoryContentsMock
.Setup(f => f.GetEnumerator())
.Returns(new List<IFileInfo> { CreatePluginConfigurationFile() }.GetEnumerator());
.Returns(new List<IFileInfo> { CreatePackageManifestFile() }.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(1, result.Count());
var first = result.First();
Assert.AreEqual("My Plugin Configuration", first.Name);
Assert.AreEqual("My Package", first.Name);
Assert.AreEqual("1.2.3", first.Version);
Assert.AreEqual(2, first.Extensions.Count());
Assert.IsTrue(first.Extensions.All(e => e is JsonElement));
}
[Test]
public async Task Can_Read_PluginConfiguration_In_Root_Directories()
public async Task Can_Read_PackageManifest_In_Root_Directories()
{
var plugin1 = CreateDirectoryMock("/my-extension", CreatePluginConfigurationFile(DefaultPluginConfigurationContent("Plugin One")));
var plugin2 = CreateDirectoryMock("/my-other-extension", CreatePluginConfigurationFile(DefaultPluginConfigurationContent("Plugin Two")));
var directoryOne = CreateDirectoryMock("/my-extension", CreatePackageManifestFile(DefaultPackageManifestContent("Package One")));
var directoryTwo = CreateDirectoryMock("/my-other-extension", CreatePackageManifestFile(DefaultPackageManifestContent("Package Two")));
_rootDirectoryContentsMock
.Setup(f => f.GetEnumerator())
.Returns(new List<IFileInfo> { plugin1, plugin2 }.GetEnumerator());
.Returns(new List<IFileInfo> { directoryOne, directoryTwo }.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(2, result.Count());
Assert.AreEqual("Plugin One", result.First().Name);
Assert.AreEqual("Plugin Two", result.Last().Name);
Assert.AreEqual("Package One", result.First().Name);
Assert.AreEqual("Package Two", result.Last().Name);
}
[Test]
public async Task Can_Read_PluginConfigurations_Recursively()
public async Task Can_Read_PackageManifests_Recursively()
{
var childFolder = CreateDirectoryMock("/my-parent-folder/my-child-folder", CreatePluginConfigurationFile(DefaultPluginConfigurationContent("Nested Plugin")));
var childFolder = CreateDirectoryMock("/my-parent-folder/my-child-folder", CreatePackageManifestFile(DefaultPackageManifestContent("Nested Package")));
var parentFolder = CreateDirectoryMock("/my-parent-folder", childFolder);
_rootDirectoryContentsMock
.Setup(f => f.GetEnumerator())
.Returns(new List<IFileInfo> { parentFolder }.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(1, result.Count());
Assert.AreEqual("Nested Plugin", result.First().Name);
Assert.AreEqual("Nested Package", result.First().Name);
}
[Test]
public async Task Can_Skip_Empty_Directories()
{
var pluginFolder = CreateDirectoryMock("/my-plugin-folder", CreatePluginConfigurationFile(DefaultPluginConfigurationContent("My Plugin")));
var packageFolder = CreateDirectoryMock("/my-package-folder", CreatePackageManifestFile(DefaultPackageManifestContent("My Package")));
var emptyFolder = CreateDirectoryMock("/my-empty-folder");
_rootDirectoryContentsMock
.Setup(f => f.GetEnumerator())
.Returns(new List<IFileInfo> { emptyFolder, pluginFolder }.GetEnumerator());
.Returns(new List<IFileInfo> { emptyFolder, packageFolder }.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(1, result.Count());
Assert.AreEqual("My Plugin", result.First().Name);
Assert.AreEqual("My Package", result.First().Name);
}
[Test]
public async Task Can_Skip_Other_Files()
{
var pluginFolder = CreateDirectoryMock(
"/my-plugin-folder",
var packageFolder = CreateDirectoryMock(
"/my-package-folder",
CreateOtherFile("my.js"),
CreatePluginConfigurationFile(DefaultPluginConfigurationContent("My Plugin")));
CreatePackageManifestFile(DefaultPackageManifestContent("My Package")));
var otherFolder = CreateDirectoryMock(
"/my-empty-folder",
CreateOtherFile("some.js"),
@@ -110,11 +110,11 @@ public class PluginConfigurationReaderTests
_rootDirectoryContentsMock
.Setup(f => f.GetEnumerator())
.Returns(new List<IFileInfo> { otherFolder, pluginFolder }.GetEnumerator());
.Returns(new List<IFileInfo> { otherFolder, packageFolder }.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(1, result.Count());
Assert.AreEqual("My Plugin", result.First().Name);
Assert.AreEqual("My Package", result.First().Name);
}
[Test]
@@ -126,12 +126,12 @@ public class PluginConfigurationReaderTests
.Setup(f => f.GetEnumerator())
.Returns(folders.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(0, result.Count());
}
[Test]
public async Task Cannot_Read_PluginConfiguration_Without_Name()
public async Task Cannot_Read_PackageManifest_Without_Name()
{
var content = @"{
""version"": ""1.2.3"",
@@ -145,16 +145,16 @@ public class PluginConfigurationReaderTests
}";
_rootDirectoryContentsMock
.Setup(f => f.GetEnumerator())
.Returns(new List<IFileInfo> { CreatePluginConfigurationFile(content) }.GetEnumerator());
.Returns(new List<IFileInfo> { CreatePackageManifestFile(content) }.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(0, result.Count());
EnsureLogErrorWasCalled();
}
[Test]
public async Task Cannot_Read_PluginConfiguration_Without_Extensions()
public async Task Cannot_Read_PackageManifest_Without_Extensions()
{
var content = @"{
""name"": ""Something"",
@@ -163,9 +163,9 @@ public class PluginConfigurationReaderTests
}";
_rootDirectoryContentsMock
.Setup(f => f.GetEnumerator())
.Returns(new List<IFileInfo> { CreatePluginConfigurationFile(content) }.GetEnumerator());
.Returns(new List<IFileInfo> { CreatePackageManifestFile(content) }.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(0, result.Count());
EnsureLogErrorWasCalled();
@@ -173,13 +173,13 @@ public class PluginConfigurationReaderTests
[TestCase("This is not JSON")]
[TestCase(@"{""name"": ""invalid-json"", ""version"": ")]
public async Task Cannot_Read_Invalid_PluginConfiguration(string content)
public async Task Cannot_Read_Invalid_PackageManifest(string content)
{
_rootDirectoryContentsMock
.Setup(f => f.GetEnumerator())
.Returns(new List<IFileInfo> { CreatePluginConfigurationFile(content) }.GetEnumerator());
.Returns(new List<IFileInfo> { CreatePackageManifestFile(content) }.GetEnumerator());
var result = await _reader.ReadPluginConfigurationsAsync();
var result = await _reader.ReadPackageManifestsAsync();
Assert.AreEqual(0, result.Count());
EnsureLogErrorWasCalled();
@@ -213,9 +213,9 @@ public class PluginConfigurationReaderTests
return fileInfo.Object;
}
private IFileInfo CreatePluginConfigurationFile(string? content = null)
private IFileInfo CreatePackageManifestFile(string? content = null)
{
content ??= DefaultPluginConfigurationContent();
content ??= DefaultPackageManifestContent();
var fileInfo = new Mock<IFileInfo>();
fileInfo.SetupGet(f => f.IsDirectory).Returns(false);
@@ -235,7 +235,7 @@ public class PluginConfigurationReaderTests
return fileInfo.Object;
}
private static string DefaultPluginConfigurationContent(string name = "My Plugin Configuration")
private static string DefaultPackageManifestContent(string name = "My Package")
=> @"{
""name"": ""##NAME##"",
""version"": ""1.2.3"",

67
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Manifest/PackageManifestServiceTests.cs Normal file
View File

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

67
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Plugin/PluginConfigurationServiceTests.cs
View File

@@ -1,67 +0,0 @@
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core.Cache;
using Umbraco.Cms.Core.Plugin;
using Umbraco.Cms.Infrastructure.Plugin;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Plugin;
[TestFixture]
public class PluginConfigurationServiceTests
{
private IPluginConfigurationService _service;
private Mock<IPluginConfigurationReader> _readerMock;
private IAppPolicyCache _runtimeCache;
[SetUp]
public void SetUp()
{
_readerMock = new Mock<IPluginConfigurationReader>();
_readerMock.Setup(r => r.ReadPluginConfigurationsAsync()).ReturnsAsync(
new[]
{
new PluginConfiguration { Name = "Test", Extensions = Array.Empty<object>() }
});
_runtimeCache = new ObjectCacheAppCache();
AppCaches appCaches = new AppCaches(
_runtimeCache,
NoAppCache.Instance,
new IsolatedCaches(type => NoAppCache.Instance));
_service = new PluginConfigurationService(_readerMock.Object, appCaches);
}
[Test]
public async Task CachesExtensionPackageConfigurations()
{
var result = await _service.GetPluginConfigurationsAsync();
Assert.AreEqual(1, result.Count());
var result2 = await _service.GetPluginConfigurationsAsync();
Assert.AreEqual(1, result2.Count());
var result3 = await _service.GetPluginConfigurationsAsync();
Assert.AreEqual(1, result3.Count());
_readerMock.Verify(r => r.ReadPluginConfigurationsAsync(), Times.Exactly(1));
}
[Test]
public async Task ReloadsExtensionPackageConfigurationsAfterCacheClear()
{
var result = await _service.GetPluginConfigurationsAsync();
Assert.AreEqual(1, result.Count());
_runtimeCache.Clear();
var result2 = await _service.GetPluginConfigurationsAsync();
Assert.AreEqual(1, result2.Count());
_runtimeCache.Clear();
var result3 = await _service.GetPluginConfigurationsAsync();
Assert.AreEqual(1, result3.Count());
_runtimeCache.Clear();
_readerMock.Verify(r => r.ReadPluginConfigurationsAsync(), Times.Exactly(3));
}
}

25
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Telemetry/TelemetryServiceTests.cs
View File

@@ -1,7 +1,6 @@
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core.Configuration;
using Umbraco.Cms.Core.Plugin;
using Umbraco.Cms.Core.Manifest;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Semver;
@@ -24,7 +23,7 @@ public class TelemetryServiceTests
siteIdentifierServiceMock.Object,
usageInformationServiceMock.Object,
Mock.Of<IMetricsConsentService>(),
Mock.Of<IPluginConfigurationService>());
Mock.Of<IPackageManifestService>());
Guid guid;
await sut.GetTelemetryReportDataAsync();
@@ -40,7 +39,7 @@ public class TelemetryServiceTests
CreateSiteIdentifierService(false),
Mock.Of<IUsageInformationService>(),
Mock.Of<IMetricsConsentService>(),
Mock.Of<IPluginConfigurationService>());
Mock.Of<IPackageManifestService>());
var result = await sut.GetTelemetryReportDataAsync();
Assert.IsNull(result);
@@ -58,7 +57,7 @@ public class TelemetryServiceTests
CreateSiteIdentifierService(),
Mock.Of<IUsageInformationService>(),
metricsConsentService.Object,
Mock.Of<IPluginConfigurationService>());
Mock.Of<IPackageManifestService>());
var result = await sut.GetTelemetryReportDataAsync();
@@ -73,12 +72,12 @@ public class TelemetryServiceTests
var versionPackageName = "VersionPackage";
var packageVersion = "1.0.0";
var noVersionPackageName = "NoVersionPackage";
PluginConfiguration[] manifests =
PackageManifest[] manifests =
{
new() { Name = versionPackageName, Version = packageVersion, Extensions = Array.Empty<object>()},
new() { Name = noVersionPackageName, Extensions = Array.Empty<object>() },
};
var extensionManifestService = CreateExtensionManifestService(manifests);
var packageManifestService = CreatePackageManifestService(manifests);
var metricsConsentService = new Mock<IMetricsConsentService>();
metricsConsentService.Setup(x => x.GetConsentLevel()).Returns(TelemetryLevel.Basic);
var sut = new TelemetryService(
@@ -86,7 +85,7 @@ public class TelemetryServiceTests
CreateSiteIdentifierService(),
Mock.Of<IUsageInformationService>(),
metricsConsentService.Object,
extensionManifestService);
packageManifestService);
var result = await sut.GetTelemetryReportDataAsync();
@@ -108,12 +107,12 @@ public class TelemetryServiceTests
public async Task RespectsAllowPackageTelemetry()
{
var version = CreateUmbracoVersion(9, 1, 1);
PluginConfiguration[] manifests =
PackageManifest[] manifests =
{
new() { Name = "DoNotTrack", AllowTelemetry = false, Extensions = Array.Empty<object>() },
new() { Name = "TrackingAllowed", AllowTelemetry = true, Extensions = Array.Empty<object>() },
};
var extensionManifestService = CreateExtensionManifestService(manifests);
var packageManifestService = CreatePackageManifestService(manifests);
var metricsConsentService = new Mock<IMetricsConsentService>();
metricsConsentService.Setup(x => x.GetConsentLevel()).Returns(TelemetryLevel.Basic);
var sut = new TelemetryService(
@@ -121,7 +120,7 @@ public class TelemetryServiceTests
CreateSiteIdentifierService(),
Mock.Of<IUsageInformationService>(),
metricsConsentService.Object,
extensionManifestService);
packageManifestService);
var result = await sut.GetTelemetryReportDataAsync();
@@ -133,10 +132,10 @@ public class TelemetryServiceTests
});
}
private IPluginConfigurationService CreateExtensionManifestService(IEnumerable<PluginConfiguration> manifests)
private IPackageManifestService CreatePackageManifestService(IEnumerable<PackageManifest> manifests)
{
var mock = new Mock<IPluginConfigurationService>();
mock.Setup(x => x.GetPluginConfigurationsAsync()).Returns(Task.FromResult(manifests));
var mock = new Mock<IPackageManifestService>();
mock.Setup(x => x.GetPackageManifestsAsync()).Returns(Task.FromResult(manifests));
return mock.Object;
}