315 lines
14 KiB
C#
315 lines
14 KiB
C#
using System.Reflection;
|
|
using System.Security.Claims;
|
|
using FluentAssertions;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.Mvc.Abstractions;
|
|
using Microsoft.AspNetCore.Mvc.Filters;
|
|
using Microsoft.AspNetCore.Mvc.ModelBinding;
|
|
using Microsoft.AspNetCore.Mvc.Routing;
|
|
using Microsoft.AspNetCore.RateLimiting;
|
|
using Microsoft.AspNetCore.Routing;
|
|
using NSubstitute;
|
|
using SlpModularCms.Core.Availability;
|
|
using SlpModularCms.Modules.Contact.Config;
|
|
using SlpModularCms.Modules.Contact.Controllers;
|
|
using SlpModularCms.Modules.Contact.Data.Entities;
|
|
using SlpModularCms.Modules.Contact.Models;
|
|
using SlpModularCms.Modules.Contact.Services;
|
|
|
|
namespace SlpModularCms.Modules.Contact.Tests;
|
|
|
|
public class ContactAdminControllerTests
|
|
{
|
|
private readonly IContactAdminService _service = Substitute.For<IContactAdminService>();
|
|
private readonly IContactSettingsService _settings = Substitute.For<IContactSettingsService>();
|
|
|
|
private ContactMessagesAdminController Messages(string? typeBase = null) => new(_service, Options.Create(new ContactOptions { Enabled = true, ProblemTypeBase = typeBase }))
|
|
{
|
|
ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() },
|
|
};
|
|
|
|
private ContactSettingsController Settings(Guid? userId = null)
|
|
{
|
|
var http = new DefaultHttpContext();
|
|
if (userId is not null)
|
|
{
|
|
http.User = new ClaimsPrincipal(new ClaimsIdentity(
|
|
[new Claim(ClaimTypes.NameIdentifier, userId.Value.ToString())], "TestAuth"));
|
|
}
|
|
|
|
return new ContactSettingsController(_settings, Options.Create(new ContactOptions { Enabled = true }))
|
|
{
|
|
ControllerContext = new ControllerContext { HttpContext = http },
|
|
};
|
|
}
|
|
|
|
private static void AssertInvalid(IActionResult result, params string[] fields)
|
|
{
|
|
var obj = result.Should().BeOfType<ObjectResult>().Subject;
|
|
obj.StatusCode.Should().Be(400);
|
|
obj.ContentTypes.Should().Contain("application/problem+json");
|
|
var problem = obj.Value.Should().BeOfType<ValidationProblemDetails>().Subject;
|
|
problem.Errors.Keys.Should().BeEquivalentTo(fields);
|
|
problem.Errors.Values.Should().OnlyContain(v => v.Length == 1 && v[0] == "invalid");
|
|
}
|
|
|
|
// ---- list ----
|
|
|
|
[Fact]
|
|
public async Task List_Returns200_WithTheServiceResult()
|
|
{
|
|
var list = new ContactMessageList([], 1, 25, 0, 0);
|
|
_service.ListAsync(null, 1, 25, Arg.Any<CancellationToken>()).Returns(list);
|
|
|
|
var result = await Messages().List(null, 1, 25);
|
|
|
|
result.Should().BeOfType<OkObjectResult>().Which.Value.Should().Be(list);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0, 25, null, "page")]
|
|
[InlineData(-3, 25, null, "page")]
|
|
[InlineData(1, 0, null, "pageSize")]
|
|
[InlineData(1, 101, null, "pageSize")]
|
|
[InlineData(1, 25, "bogus", "status")]
|
|
[InlineData(1, 25, "converted", "status")]
|
|
public async Task List_Returns400_NamingTheBadParameter(int page, int pageSize, string? status, string field)
|
|
{
|
|
var result = await Messages().List(status, page, pageSize);
|
|
|
|
AssertInvalid(result, field);
|
|
await _service.DidNotReceive().ListAsync(Arg.Any<string?>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<CancellationToken>());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task List_Returns400_ForAnUnparsablePageNumber()
|
|
{
|
|
var controller = Messages();
|
|
controller.ModelState.AddModelError("page", "The value 'abc' is not valid.");
|
|
|
|
var result = await controller.List(null);
|
|
|
|
AssertInvalid(result, "page");
|
|
}
|
|
|
|
// ---- detail, status, delete, resend ----
|
|
|
|
[Fact]
|
|
public async Task Get_Returns200_Or404()
|
|
{
|
|
var id = Guid.NewGuid();
|
|
_service.GetAsync(id, Arg.Any<CancellationToken>()).Returns((ContactMessageDetail?)null);
|
|
(await Messages().Get(id, CancellationToken.None)).Should().BeOfType<NotFoundResult>();
|
|
|
|
var detail = new ContactMessageDetail(id.ToString(), DateTimeOffset.UtcNow, "n", "e", "s", "m", "new", "pending", 0, null, DateTimeOffset.UtcNow);
|
|
_service.GetAsync(id, Arg.Any<CancellationToken>()).Returns(detail);
|
|
(await Messages().Get(id, CancellationToken.None)).Should().BeOfType<OkObjectResult>().Which.Value.Should().Be(detail);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("new", ContactMessageStatus.New)]
|
|
[InlineData("read", ContactMessageStatus.Read)]
|
|
[InlineData("archived", ContactMessageStatus.Archived)]
|
|
[InlineData("ARCHIVED", ContactMessageStatus.Archived)]
|
|
public async Task SetStatus_AcceptsNewReadArchived(string value, ContactMessageStatus expected)
|
|
{
|
|
var id = Guid.NewGuid();
|
|
var detail = new ContactMessageDetail(id.ToString(), DateTimeOffset.UtcNow, "n", "e", "s", "m", value.ToLowerInvariant(), "pending", 0, null, DateTimeOffset.UtcNow);
|
|
_service.SetStatusAsync(id, expected, Arg.Any<CancellationToken>()).Returns(detail);
|
|
|
|
var result = await Messages().SetStatus(id, new UpdateContactMessageStatusRequest(value), CancellationToken.None);
|
|
|
|
result.Should().BeOfType<OkObjectResult>().Which.Value.Should().Be(detail);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(null)]
|
|
[InlineData("")]
|
|
[InlineData("spam")]
|
|
[InlineData("converted")]
|
|
[InlineData("deleted")]
|
|
public async Task SetStatus_RejectsEverythingElse_WithErrorsStatus(string? value)
|
|
{
|
|
var result = await Messages().SetStatus(Guid.NewGuid(), new UpdateContactMessageStatusRequest(value), CancellationToken.None);
|
|
|
|
AssertInvalid(result, "status");
|
|
await _service.DidNotReceive().SetStatusAsync(Arg.Any<Guid>(), Arg.Any<ContactMessageStatus>(), Arg.Any<CancellationToken>());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SetStatus_RejectsAnUnreadableBody()
|
|
{
|
|
var controller = Messages();
|
|
controller.ModelState.AddModelError("$.status", "bad");
|
|
|
|
AssertInvalid(await controller.SetStatus(Guid.NewGuid(), null, CancellationToken.None), "status");
|
|
AssertInvalid(await Messages().SetStatus(Guid.NewGuid(), null, CancellationToken.None), "status");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SetStatus_Returns404_ForAnUnknownMessage()
|
|
{
|
|
_service.SetStatusAsync(Arg.Any<Guid>(), Arg.Any<ContactMessageStatus>(), Arg.Any<CancellationToken>()).Returns((ContactMessageDetail?)null);
|
|
|
|
(await Messages().SetStatus(Guid.NewGuid(), new UpdateContactMessageStatusRequest("read"), CancellationToken.None))
|
|
.Should().BeOfType<NotFoundResult>();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Delete_Returns204_Or404()
|
|
{
|
|
var id = Guid.NewGuid();
|
|
_service.DeleteAsync(id, Arg.Any<CancellationToken>()).Returns(true, false);
|
|
|
|
(await Messages().Delete(id, CancellationToken.None)).Should().BeOfType<NoContentResult>();
|
|
(await Messages().Delete(id, CancellationToken.None)).Should().BeOfType<NotFoundResult>();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Resend_Returns200_404_Or409ForSpam()
|
|
{
|
|
var id = Guid.NewGuid();
|
|
var result = new ContactResendResult("sent", 1, true);
|
|
_service.ResendAsync(id, Arg.Any<CancellationToken>()).Returns(result);
|
|
(await Messages().Resend(id, CancellationToken.None)).Should().BeOfType<OkObjectResult>().Which.Value.Should().Be(result);
|
|
|
|
_service.ResendAsync(id, Arg.Any<CancellationToken>()).Returns((ContactResendResult?)null);
|
|
(await Messages().Resend(id, CancellationToken.None)).Should().BeOfType<NotFoundResult>();
|
|
|
|
_service.ResendAsync(id, Arg.Any<CancellationToken>()).Returns<Task<ContactResendResult?>>(_ => throw new ContactResendNotAllowedException());
|
|
var conflict = (ObjectResult)await Messages().Resend(id, CancellationToken.None);
|
|
conflict.StatusCode.Should().Be(409);
|
|
conflict.ContentTypes.Should().Contain("application/problem+json");
|
|
conflict.Value.Should().BeOfType<ProblemDetails>().Which.Status.Should().Be(409);
|
|
}
|
|
|
|
// ---- settings ----
|
|
|
|
[Fact]
|
|
public async Task GetSettings_ReturnsTheSingleton()
|
|
{
|
|
_settings.GetAsync(Arg.Any<CancellationToken>()).Returns(new ContactSettingsDto(false, true));
|
|
|
|
var result = await Settings().Get(CancellationToken.None);
|
|
|
|
result.Should().BeOfType<OkObjectResult>().Which.Value.Should().Be(new ContactSettingsDto(false, true));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(true)]
|
|
[InlineData(false)]
|
|
public async Task PutSettings_StoresTheBoolean_RecordingWhoDidIt(bool enabled)
|
|
{
|
|
var user = Guid.NewGuid();
|
|
_settings.SetEnabledAsync(enabled, user, Arg.Any<CancellationToken>()).Returns(new ContactSettingsDto(enabled, true));
|
|
|
|
var result = await Settings(user).Put(new UpdateContactSettingsRequest(enabled), CancellationToken.None);
|
|
|
|
result.Should().BeOfType<OkObjectResult>().Which.Value.Should().Be(new ContactSettingsDto(enabled, true));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PutSettings_RejectsAMissingNullOrNonBooleanValue_WithErrorsEnabled()
|
|
{
|
|
AssertInvalid(await Settings().Put(null, CancellationToken.None), "enabled");
|
|
AssertInvalid(await Settings().Put(new UpdateContactSettingsRequest(null), CancellationToken.None), "enabled");
|
|
|
|
var controller = Settings();
|
|
controller.ModelState.AddModelError("$.enabled", "The JSON value could not be converted to System.Boolean.");
|
|
AssertInvalid(await controller.Put(new UpdateContactSettingsRequest(true), CancellationToken.None), "enabled");
|
|
|
|
await _settings.DidNotReceive().SetEnabledAsync(Arg.Any<bool>(), Arg.Any<Guid>(), Arg.Any<CancellationToken>());
|
|
}
|
|
|
|
// ---- route table (every route of the management side) ----
|
|
|
|
private static readonly Type[] AdminControllers = [typeof(ContactMessagesAdminController), typeof(ContactSettingsController)];
|
|
|
|
private static IEnumerable<(Type Controller, MethodInfo Action, HttpMethodAttribute Http)> AdminActions() =>
|
|
AdminControllers.SelectMany(c => c
|
|
.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
|
|
.Select(m => (Controller: c, Action: m, Http: m.GetCustomAttributes<HttpMethodAttribute>().SingleOrDefault()))
|
|
.Where(x => x.Http is not null)
|
|
.Select(x => (x.Controller, x.Action, x.Http!)));
|
|
|
|
[Fact]
|
|
public void RouteTable_TheManagementRoutesAreExactlyTheAgreedSet()
|
|
{
|
|
AdminActions().Select(a =>
|
|
$"{a.Http.HttpMethods.Single()} {a.Controller.GetCustomAttribute<RouteAttribute>()!.Template}/{a.Http.Template}".TrimEnd('/'))
|
|
.Should().BeEquivalentTo(
|
|
[
|
|
"GET contact-messages",
|
|
"GET contact-messages/{id:guid}",
|
|
"PATCH contact-messages/{id:guid}",
|
|
"DELETE contact-messages/{id:guid}",
|
|
"POST contact-messages/{id:guid}/resend",
|
|
"GET contact-settings",
|
|
"PUT contact-settings",
|
|
"PUT contact-settings/recipient",
|
|
]);
|
|
}
|
|
|
|
[Fact]
|
|
public void RouteTable_EveryManagementRoute_IsAdminOnly_NeverAnonymous_NeverPublic_AndHasNoAdminSegment()
|
|
{
|
|
foreach (var controller in AdminControllers)
|
|
{
|
|
controller.GetCustomAttribute<AuthorizeAttribute>()!.Policy.Should().Be("AdminOnly");
|
|
controller.GetCustomAttribute<ServiceFilterAttribute>()!.ServiceType.Should().Be(typeof(ContactAdminRouteFilter));
|
|
controller.GetCustomAttribute<RouteAttribute>()!.Template.Should().NotContainEquivalentOf("admin");
|
|
}
|
|
|
|
foreach (var (controller, action, http) in AdminActions())
|
|
{
|
|
var name = $"{controller.Name}.{action.Name}";
|
|
action.GetCustomAttribute<AllowAnonymousAttribute>().Should().BeNull($"{name} must not be anonymous");
|
|
action.GetCustomAttribute<PublicSiteEndpointAttribute>().Should().BeNull($"{name} must stay behind the availability gate");
|
|
action.GetCustomAttributes<AuthorizeAttribute>().Where(a => a.Policy != "AdminOnly").Should().BeEmpty();
|
|
(http.Template ?? string.Empty).Should().NotContainEquivalentOf("admin");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void RouteTable_OnlyTwoActionsOfTheWholeContactModuleArePublic()
|
|
{
|
|
var publicActions = typeof(ContactModule).Assembly.GetTypes()
|
|
.Where(t => typeof(ControllerBase).IsAssignableFrom(t) && !t.IsAbstract)
|
|
.SelectMany(t => t.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
|
|
.Where(m => m.GetCustomAttribute<PublicSiteEndpointAttribute>() is not null)
|
|
.Select(m => $"{m.DeclaringType!.Name}.{m.Name}");
|
|
|
|
publicActions.Should().BeEquivalentTo(
|
|
$"{nameof(ContactMessagesController)}.{nameof(ContactMessagesController.GetToken)}",
|
|
$"{nameof(ContactMessagesController)}.{nameof(ContactMessagesController.Submit)}");
|
|
}
|
|
|
|
[Fact]
|
|
public void ResendHasItsOwnRateLimitPolicy()
|
|
{
|
|
typeof(ContactMessagesAdminController).GetMethod(nameof(ContactMessagesAdminController.Resend))!
|
|
.GetCustomAttribute<EnableRateLimitingAttribute>()!.PolicyName.Should().Be("contact-resend");
|
|
}
|
|
|
|
// ---- the host switch on the management side ----
|
|
|
|
private static ResourceExecutingContext ResourceContext() => new(
|
|
new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor()),
|
|
new List<IFilterMetadata>(),
|
|
new List<IValueProviderFactory>());
|
|
|
|
[Fact]
|
|
public void AdminRouteFilter_Answers404_WhileTheHostSwitchIsOff_AndPassesWhenItIsOn()
|
|
{
|
|
var off = ResourceContext();
|
|
new ContactAdminRouteFilter(Options.Create(new ContactOptions { Enabled = false })).OnResourceExecuting(off);
|
|
off.Result.Should().BeOfType<NotFoundResult>();
|
|
|
|
var on = ResourceContext();
|
|
new ContactAdminRouteFilter(Options.Create(new ContactOptions { Enabled = true })).OnResourceExecuting(on);
|
|
on.Result.Should().BeNull();
|
|
}
|
|
}
|