af7fd25a69
Pick a folder or type a path (a new one is created on save); new items start in the folder they were created from and copies stay with the draft's folder. A folder changed from the editor is audited as a move (moved / sequence-moved), like a move from the list. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
402 lines
26 KiB
C#
402 lines
26 KiB
C#
using System.Net;
|
|
using System.Net.Http.Json;
|
|
using Backend.Data;
|
|
using Backend.Security;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Shared.Contracts.Api;
|
|
using Shared.Contracts.Serialization;
|
|
using Xunit;
|
|
|
|
namespace Backend.Tests;
|
|
|
|
/// <summary>Folders of scripts, function modules and sequences (and the vault's folder tree): rules, moves and permissions.</summary>
|
|
public class LibraryFolderTests(BackendTestFixture fixture) : IClassFixture<BackendTestFixture>
|
|
{
|
|
private static async Task<IReadOnlyList<string>> FoldersAsync(HttpClient client, string route)
|
|
=> (await client.GetFromJsonAsync<List<string>>(route, JsonDefaults.Options))!;
|
|
|
|
private static Task<HttpResponseMessage> CreateFolderAsync(HttpClient client, string route, string path)
|
|
=> client.PostAsJsonAsync(route, new FolderRequest(path), JsonDefaults.Options);
|
|
|
|
private static Task<HttpResponseMessage> DeleteFolderAsync(HttpClient client, string route, string path)
|
|
=> client.DeleteAsync($"{route}?path={Uri.EscapeDataString(path)}");
|
|
|
|
private static async Task<ScriptDto> CreateScriptAsync(HttpClient client, string name, string? folder)
|
|
{
|
|
var response = await client.PostAsJsonAsync(ApiRoutes.Scripts,
|
|
new SaveScriptRequest(name, null, "Write-Output 'hi'", Folder: folder), JsonDefaults.Options);
|
|
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
|
|
return (await response.Content.ReadFromJsonAsync<ScriptDto>(JsonDefaults.Options))!;
|
|
}
|
|
|
|
private static async Task<FunctionModuleDto> CreateFunctionAsync(HttpClient client, string name, string? folder)
|
|
{
|
|
var response = await client.PostAsJsonAsync(ApiRoutes.FunctionModules,
|
|
new SaveFunctionModuleRequest(name, null, "function Test-It {}", folder), JsonDefaults.Options);
|
|
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
|
|
return (await response.Content.ReadFromJsonAsync<FunctionModuleDto>(JsonDefaults.Options))!;
|
|
}
|
|
|
|
private static async Task<string> ScriptFolderAsync(HttpClient client, Guid id)
|
|
=> (await client.GetFromJsonAsync<ScriptDto>(ApiRoutes.For.Script(id), JsonDefaults.Options))!.Folder;
|
|
|
|
private static async Task<SequenceDto> CreateSequenceAsync(HttpClient client, string name, string? folder)
|
|
{
|
|
var response = await client.PostAsJsonAsync(ApiRoutes.Sequences, new SaveSequenceRequest(name, null, [], folder), JsonDefaults.Options);
|
|
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
|
|
return (await response.Content.ReadFromJsonAsync<SequenceDto>(JsonDefaults.Options))!;
|
|
}
|
|
|
|
private static async Task<string> SequenceFolderAsync(HttpClient client, Guid id)
|
|
=> (await client.GetFromJsonAsync<SequenceDto>(ApiRoutes.For.Sequence(id), JsonDefaults.Options))!.Folder;
|
|
|
|
/// <summary>A signed-in client whose only role grants exactly <paramref name="permissions"/>.</summary>
|
|
private async Task<HttpClient> SignedInWithAsync(string username, params string[] permissions)
|
|
{
|
|
var roleId = await fixture.WithDbAsync(async db =>
|
|
{
|
|
var role = new RoleEntity
|
|
{
|
|
Id = Guid.NewGuid(), Name = $"folders-{Guid.NewGuid():N}",
|
|
PermissionsJson = JsonDefaults.Serialize(permissions),
|
|
CreatedUtc = DateTimeOffset.UtcNow, UpdatedUtc = DateTimeOffset.UtcNow,
|
|
};
|
|
db.Roles.Add(role);
|
|
await db.SaveChangesAsync();
|
|
return role.Id;
|
|
});
|
|
return await fixture.SignedInAsync(username, roleId: roleId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ScriptFoldersAreCreatedRenamedAndDeletedOnlyWhenEmpty()
|
|
{
|
|
using var admin = await fixture.SignedInAsync("folders-scripts");
|
|
var created = await CreateFolderAsync(admin, ApiRoutes.ScriptFolders, " /Ops//Network ");
|
|
created.EnsureSuccessStatusCode();
|
|
Assert.Equal(new FolderDto("/Ops/Network", "Network"), await created.Content.ReadFromJsonAsync<FolderDto>(JsonDefaults.Options));
|
|
|
|
// The folders above a new one exist too, and an empty folder stays.
|
|
var folders = await FoldersAsync(admin, ApiRoutes.ScriptFolders);
|
|
Assert.Contains("/Ops", folders);
|
|
Assert.Contains("/Ops/Network", folders);
|
|
|
|
Assert.Equal(HttpStatusCode.Conflict, (await CreateFolderAsync(admin, ApiRoutes.ScriptFolders, "/ops/NETWORK")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await CreateFolderAsync(admin, ApiRoutes.ScriptFolders, "/")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await CreateFolderAsync(admin, ApiRoutes.ScriptFolders, "/a/../b")).StatusCode);
|
|
|
|
// A script lands in the existing folder, whatever the casing it was given.
|
|
var script = await CreateScriptAsync(admin, "Folder Probe", "/ops/network");
|
|
Assert.Equal("/Ops/Network", script.Folder);
|
|
|
|
// Not empty: neither the folder holding the script nor the one above it can go.
|
|
Assert.Equal(HttpStatusCode.Conflict, (await DeleteFolderAsync(admin, ApiRoutes.ScriptFolders, "/Ops/Network")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Conflict, (await DeleteFolderAsync(admin, ApiRoutes.ScriptFolders, "/Ops")).StatusCode);
|
|
|
|
// Renaming a folder carries the script with it.
|
|
var moved = await admin.PostAsJsonAsync(ApiRoutes.ScriptFolderMove, new MoveFolderRequest("/ops", "/Infra"), JsonDefaults.Options);
|
|
moved.EnsureSuccessStatusCode();
|
|
Assert.Equal("/Infra/Network", await ScriptFolderAsync(admin, script.Id));
|
|
folders = await FoldersAsync(admin, ApiRoutes.ScriptFolders);
|
|
Assert.Contains("/Infra/Network", folders);
|
|
Assert.DoesNotContain(folders, f => f.StartsWith("/Ops", StringComparison.OrdinalIgnoreCase));
|
|
|
|
var inside = await admin.PostAsJsonAsync(ApiRoutes.ScriptFolderMove, new MoveFolderRequest("/Infra", "/Infra/Network/Deeper"), JsonDefaults.Options);
|
|
Assert.Equal(HttpStatusCode.BadRequest, inside.StatusCode);
|
|
await CreateFolderAsync(admin, ApiRoutes.ScriptFolders, "/Taken");
|
|
var onto = await admin.PostAsJsonAsync(ApiRoutes.ScriptFolderMove, new MoveFolderRequest("/Infra", "/taken"), JsonDefaults.Options);
|
|
Assert.Equal(HttpStatusCode.Conflict, onto.StatusCode);
|
|
var missing = await admin.PostAsJsonAsync(ApiRoutes.ScriptFolderMove, new MoveFolderRequest("/Nowhere", "/Elsewhere"), JsonDefaults.Options);
|
|
Assert.Equal(HttpStatusCode.NotFound, missing.StatusCode);
|
|
|
|
// A case-only rename is a rename.
|
|
(await admin.PostAsJsonAsync(ApiRoutes.ScriptFolderMove, new MoveFolderRequest("/Infra", "/INFRA"), JsonDefaults.Options)).EnsureSuccessStatusCode();
|
|
Assert.Equal("/INFRA/Network", await ScriptFolderAsync(admin, script.Id));
|
|
|
|
// Once the script moves out, the emptied folders remain until deleted.
|
|
var toTop = await admin.PostAsJsonAsync(ApiRoutes.ScriptsMove, new MoveToFolderRequest([script.Id], "/"), JsonDefaults.Options);
|
|
toTop.EnsureSuccessStatusCode();
|
|
Assert.Equal(new MoveToFolderResultDto("/", 1), await toTop.Content.ReadFromJsonAsync<MoveToFolderResultDto>(JsonDefaults.Options));
|
|
Assert.Equal("/", await ScriptFolderAsync(admin, script.Id));
|
|
Assert.Contains("/INFRA/Network", await FoldersAsync(admin, ApiRoutes.ScriptFolders));
|
|
|
|
Assert.Equal(HttpStatusCode.Conflict, (await DeleteFolderAsync(admin, ApiRoutes.ScriptFolders, "/INFRA")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.NoContent, (await DeleteFolderAsync(admin, ApiRoutes.ScriptFolders, "/infra/network")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.NoContent, (await DeleteFolderAsync(admin, ApiRoutes.ScriptFolders, "/INFRA")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.NotFound, (await DeleteFolderAsync(admin, ApiRoutes.ScriptFolders, "/INFRA")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await DeleteFolderAsync(admin, ApiRoutes.ScriptFolders, "/")).StatusCode);
|
|
Assert.DoesNotContain(await FoldersAsync(admin, ApiRoutes.ScriptFolders), f => f.StartsWith("/INFRA", StringComparison.Ordinal));
|
|
|
|
foreach (var action in new[] { "script-folder-created", "script-folder-moved", "script-folder-deleted", "script-moved" })
|
|
{
|
|
Assert.True(await fixture.WithDbAsync(db => db.AuditEvents.AnyAsync(
|
|
e => e.Category == AuditCategories.Scripts && e.Action == action && e.Actor == "folders-scripts")), action);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ScriptsMoveBetweenFoldersAndKeepTheirFolderWhenSaved()
|
|
{
|
|
using var admin = await fixture.SignedInAsync("folders-items");
|
|
var top = await CreateScriptAsync(admin, "Top Level", null);
|
|
Assert.Equal("/", top.Folder);
|
|
var first = await CreateScriptAsync(admin, "First", "/Moves/From");
|
|
var second = await CreateScriptAsync(admin, "Second", "/Moves/From");
|
|
|
|
// A move into a folder that does not exist yet creates it.
|
|
var moved = await admin.PostAsJsonAsync(ApiRoutes.ScriptsMove,
|
|
new MoveToFolderRequest([first.Id, second.Id], "/Moves/To/Deep"), JsonDefaults.Options);
|
|
moved.EnsureSuccessStatusCode();
|
|
Assert.Equal(2, (await moved.Content.ReadFromJsonAsync<MoveToFolderResultDto>(JsonDefaults.Options))!.Moved);
|
|
Assert.Equal("/Moves/To/Deep", await ScriptFolderAsync(admin, first.Id));
|
|
var folders = await FoldersAsync(admin, ApiRoutes.ScriptFolders);
|
|
Assert.Contains("/Moves/To", folders);
|
|
Assert.Contains("/Moves/From", folders);
|
|
|
|
// Saving without a folder keeps the script where it is; with one, moves it.
|
|
var keep = await admin.PutAsJsonAsync(ApiRoutes.For.Script(first.Id),
|
|
new SaveScriptRequest("First", "edited", "Write-Output 1"), JsonDefaults.Options);
|
|
keep.EnsureSuccessStatusCode();
|
|
Assert.Equal("/Moves/To/Deep", await ScriptFolderAsync(admin, first.Id));
|
|
(await admin.PutAsJsonAsync(ApiRoutes.For.Script(first.Id),
|
|
new SaveScriptRequest("First", "edited", "Write-Output 1", Folder: "/moves/from"), JsonDefaults.Options)).EnsureSuccessStatusCode();
|
|
Assert.Equal("/Moves/From", await ScriptFolderAsync(admin, first.Id));
|
|
// The editor's Folder is audited as a move; a save that keeps the folder is not.
|
|
Assert.Equal(1, await fixture.WithDbAsync(db => db.AuditEvents.CountAsync(e => e.Action == "moved" && e.Actor == "folders-items"
|
|
&& e.Detail != null && e.Detail.StartsWith("First:"))));
|
|
Assert.True(await fixture.WithDbAsync(db => db.AuditEvents.AnyAsync(
|
|
e => e.Action == "moved" && e.Detail == "First: /Moves/To/Deep → /Moves/From")));
|
|
|
|
// Unknown ids refuse the whole move.
|
|
var unknown = await admin.PostAsJsonAsync(ApiRoutes.ScriptsMove,
|
|
new MoveToFolderRequest([second.Id, Guid.NewGuid()], "/"), JsonDefaults.Options);
|
|
Assert.Equal(HttpStatusCode.NotFound, unknown.StatusCode);
|
|
Assert.Equal("/Moves/To/Deep", await ScriptFolderAsync(admin, second.Id));
|
|
var bad = await admin.PostAsJsonAsync(ApiRoutes.Scripts,
|
|
new SaveScriptRequest("Bad", null, "", Folder: "/x/./y"), JsonDefaults.Options);
|
|
Assert.Equal(HttpStatusCode.BadRequest, bad.StatusCode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FunctionsHaveTheirOwnFolders()
|
|
{
|
|
using var admin = await fixture.SignedInAsync("folders-functions");
|
|
var module = await CreateFunctionAsync(admin, "Shared Helpers", "/Lib/Net");
|
|
Assert.Equal("/Lib/Net", module.Folder);
|
|
|
|
var functionFolders = await FoldersAsync(admin, ApiRoutes.FunctionFolders);
|
|
Assert.Contains("/Lib", functionFolders);
|
|
Assert.Contains("/Lib/Net", functionFolders);
|
|
// Scripts and functions keep separate trees.
|
|
Assert.DoesNotContain("/Lib", await FoldersAsync(admin, ApiRoutes.ScriptFolders));
|
|
|
|
Assert.Equal(HttpStatusCode.Conflict, (await DeleteFolderAsync(admin, ApiRoutes.FunctionFolders, "/Lib/Net")).StatusCode);
|
|
var moved = await admin.PostAsJsonAsync(ApiRoutes.FunctionModulesMove, new MoveToFolderRequest([module.Id], "/Lib"), JsonDefaults.Options);
|
|
moved.EnsureSuccessStatusCode();
|
|
Assert.Equal(HttpStatusCode.NoContent, (await DeleteFolderAsync(admin, ApiRoutes.FunctionFolders, "/Lib/Net")).StatusCode);
|
|
|
|
(await admin.PostAsJsonAsync(ApiRoutes.FunctionFolderMove, new MoveFolderRequest("/Lib", "/Library"), JsonDefaults.Options)).EnsureSuccessStatusCode();
|
|
var reloaded = await admin.GetFromJsonAsync<FunctionModuleDto>(ApiRoutes.For.FunctionModule(module.Id), JsonDefaults.Options);
|
|
Assert.Equal("/Library", reloaded!.Folder);
|
|
|
|
// An update without a folder keeps it.
|
|
var saved = await admin.PutAsJsonAsync(ApiRoutes.For.FunctionModule(module.Id),
|
|
new SaveFunctionModuleRequest("Shared Helpers", "now described", "function Test-It {}"), JsonDefaults.Options);
|
|
Assert.Equal("/Library", (await saved.Content.ReadFromJsonAsync<FunctionModuleDto>(JsonDefaults.Options))!.Folder);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SequenceFoldersAreCreatedRenamedAndDeletedOnlyWhenEmpty()
|
|
{
|
|
using var admin = await fixture.SignedInAsync("folders-sequences");
|
|
var created = await CreateFolderAsync(admin, ApiRoutes.SequenceFolders, " /Builds//Servers ");
|
|
created.EnsureSuccessStatusCode();
|
|
Assert.Equal(new FolderDto("/Builds/Servers", "Servers"), await created.Content.ReadFromJsonAsync<FolderDto>(JsonDefaults.Options));
|
|
|
|
var folders = await FoldersAsync(admin, ApiRoutes.SequenceFolders);
|
|
Assert.Contains("/Builds", folders);
|
|
Assert.Contains("/Builds/Servers", folders);
|
|
// Sequences keep their own tree.
|
|
Assert.DoesNotContain("/Builds", await FoldersAsync(admin, ApiRoutes.ScriptFolders));
|
|
Assert.DoesNotContain("/Builds", await FoldersAsync(admin, ApiRoutes.FunctionFolders));
|
|
|
|
Assert.Equal(HttpStatusCode.Conflict, (await CreateFolderAsync(admin, ApiRoutes.SequenceFolders, "/builds/SERVERS")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await CreateFolderAsync(admin, ApiRoutes.SequenceFolders, "/")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await CreateFolderAsync(admin, ApiRoutes.SequenceFolders, "/a/../b")).StatusCode);
|
|
|
|
var sequence = await CreateSequenceAsync(admin, "Folder Probe", "/builds/servers");
|
|
Assert.Equal("/Builds/Servers", sequence.Folder);
|
|
|
|
Assert.Equal(HttpStatusCode.Conflict, (await DeleteFolderAsync(admin, ApiRoutes.SequenceFolders, "/Builds/Servers")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Conflict, (await DeleteFolderAsync(admin, ApiRoutes.SequenceFolders, "/Builds")).StatusCode);
|
|
|
|
// Renaming a folder carries the sequence with it.
|
|
(await admin.PostAsJsonAsync(ApiRoutes.SequenceFolderMove, new MoveFolderRequest("/builds", "/Imaging"), JsonDefaults.Options))
|
|
.EnsureSuccessStatusCode();
|
|
Assert.Equal("/Imaging/Servers", await SequenceFolderAsync(admin, sequence.Id));
|
|
folders = await FoldersAsync(admin, ApiRoutes.SequenceFolders);
|
|
Assert.Contains("/Imaging/Servers", folders);
|
|
Assert.DoesNotContain(folders, f => f.StartsWith("/Builds", StringComparison.OrdinalIgnoreCase));
|
|
|
|
Assert.Equal(HttpStatusCode.BadRequest,
|
|
(await admin.PostAsJsonAsync(ApiRoutes.SequenceFolderMove, new MoveFolderRequest("/Imaging", "/Imaging/Servers/Deeper"), JsonDefaults.Options)).StatusCode);
|
|
await CreateFolderAsync(admin, ApiRoutes.SequenceFolders, "/Taken");
|
|
Assert.Equal(HttpStatusCode.Conflict,
|
|
(await admin.PostAsJsonAsync(ApiRoutes.SequenceFolderMove, new MoveFolderRequest("/Imaging", "/taken"), JsonDefaults.Options)).StatusCode);
|
|
Assert.Equal(HttpStatusCode.NotFound,
|
|
(await admin.PostAsJsonAsync(ApiRoutes.SequenceFolderMove, new MoveFolderRequest("/Nowhere", "/Elsewhere"), JsonDefaults.Options)).StatusCode);
|
|
|
|
// A case-only rename is a rename.
|
|
(await admin.PostAsJsonAsync(ApiRoutes.SequenceFolderMove, new MoveFolderRequest("/Imaging", "/IMAGING"), JsonDefaults.Options))
|
|
.EnsureSuccessStatusCode();
|
|
Assert.Equal("/IMAGING/Servers", await SequenceFolderAsync(admin, sequence.Id));
|
|
|
|
var toTop = await admin.PostAsJsonAsync(ApiRoutes.SequencesMove, new MoveToFolderRequest([sequence.Id], "/"), JsonDefaults.Options);
|
|
toTop.EnsureSuccessStatusCode();
|
|
Assert.Equal(new MoveToFolderResultDto("/", 1), await toTop.Content.ReadFromJsonAsync<MoveToFolderResultDto>(JsonDefaults.Options));
|
|
Assert.Equal("/", await SequenceFolderAsync(admin, sequence.Id));
|
|
Assert.Contains("/IMAGING/Servers", await FoldersAsync(admin, ApiRoutes.SequenceFolders));
|
|
|
|
Assert.Equal(HttpStatusCode.Conflict, (await DeleteFolderAsync(admin, ApiRoutes.SequenceFolders, "/IMAGING")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.NoContent, (await DeleteFolderAsync(admin, ApiRoutes.SequenceFolders, "/imaging/servers")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.NoContent, (await DeleteFolderAsync(admin, ApiRoutes.SequenceFolders, "/IMAGING")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.NotFound, (await DeleteFolderAsync(admin, ApiRoutes.SequenceFolders, "/IMAGING")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await DeleteFolderAsync(admin, ApiRoutes.SequenceFolders, "/")).StatusCode);
|
|
|
|
foreach (var action in new[] { "sequence-folder-created", "sequence-folder-moved", "sequence-folder-deleted", "sequence-moved" })
|
|
{
|
|
Assert.True(await fixture.WithDbAsync(db => db.AuditEvents.AnyAsync(
|
|
e => e.Category == AuditCategories.Scripts && e.Action == action && e.Actor == "folders-sequences")), action);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SequencesMoveBetweenFoldersAndKeepTheirFolderWhenSaved()
|
|
{
|
|
using var admin = await fixture.SignedInAsync("folders-sequence-items");
|
|
var top = await CreateSequenceAsync(admin, "Top Sequence", null);
|
|
Assert.Equal("/", top.Folder);
|
|
var first = await CreateSequenceAsync(admin, "First Sequence", "/SeqMoves/From");
|
|
var second = await CreateSequenceAsync(admin, "Second Sequence", "/SeqMoves/From");
|
|
|
|
// A bulk move into a folder that does not exist yet creates it.
|
|
var moved = await admin.PostAsJsonAsync(ApiRoutes.SequencesMove,
|
|
new MoveToFolderRequest([first.Id, second.Id], "/SeqMoves/To/Deep"), JsonDefaults.Options);
|
|
moved.EnsureSuccessStatusCode();
|
|
Assert.Equal(2, (await moved.Content.ReadFromJsonAsync<MoveToFolderResultDto>(JsonDefaults.Options))!.Moved);
|
|
Assert.Equal("/SeqMoves/To/Deep", await SequenceFolderAsync(admin, second.Id));
|
|
var folders = await FoldersAsync(admin, ApiRoutes.SequenceFolders);
|
|
Assert.Contains("/SeqMoves/To", folders);
|
|
Assert.Contains("/SeqMoves/From", folders);
|
|
Assert.Contains((await admin.GetFromJsonAsync<List<SequenceDto>>(ApiRoutes.Sequences, JsonDefaults.Options))!,
|
|
s => s.Id == first.Id && s.Folder == "/SeqMoves/To/Deep");
|
|
|
|
// Saving without a folder keeps the sequence where it is; with one, moves it.
|
|
(await admin.PutAsJsonAsync(ApiRoutes.For.Sequence(first.Id), new SaveSequenceRequest("First Sequence", "edited", []), JsonDefaults.Options))
|
|
.EnsureSuccessStatusCode();
|
|
Assert.Equal("/SeqMoves/To/Deep", await SequenceFolderAsync(admin, first.Id));
|
|
var refiled = await admin.PutAsJsonAsync(ApiRoutes.For.Sequence(first.Id),
|
|
new SaveSequenceRequest("First Sequence", "edited", [], "/seqmoves/from"), JsonDefaults.Options);
|
|
refiled.EnsureSuccessStatusCode();
|
|
Assert.Equal("/SeqMoves/From", (await refiled.Content.ReadFromJsonAsync<SequenceDto>(JsonDefaults.Options))!.Folder);
|
|
Assert.Equal(1, await fixture.WithDbAsync(db => db.AuditEvents.CountAsync(e => e.Action == "sequence-moved"
|
|
&& e.Actor == "folders-sequence-items" && e.Detail == "First Sequence: /SeqMoves/To/Deep → /SeqMoves/From")));
|
|
|
|
// Unknown ids refuse the whole move; bad paths are refused on save as for scripts.
|
|
Assert.Equal(HttpStatusCode.NotFound, (await admin.PostAsJsonAsync(ApiRoutes.SequencesMove,
|
|
new MoveToFolderRequest([second.Id, Guid.NewGuid()], "/"), JsonDefaults.Options)).StatusCode);
|
|
Assert.Equal("/SeqMoves/To/Deep", await SequenceFolderAsync(admin, second.Id));
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await admin.PostAsJsonAsync(ApiRoutes.SequencesMove,
|
|
new MoveToFolderRequest([], "/"), JsonDefaults.Options)).StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await admin.PostAsJsonAsync(ApiRoutes.Sequences,
|
|
new SaveSequenceRequest("Bad", null, [], "/x/./y"), JsonDefaults.Options)).StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, (await admin.PutAsJsonAsync(ApiRoutes.For.Sequence(second.Id),
|
|
new SaveSequenceRequest("Second Sequence", null, [], "/" + new string('a', 101)), JsonDefaults.Options)).StatusCode);
|
|
Assert.Equal("/SeqMoves/To/Deep", await SequenceFolderAsync(admin, second.Id));
|
|
Assert.False(await fixture.WithDbAsync(db => db.Sequences.AnyAsync(s => s.Name == "Bad")));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ViewingNeedsTheViewPermissionAndChangesTheManageOne()
|
|
{
|
|
using var admin = await fixture.SignedInAsync("folders-perm-admin");
|
|
var script = await CreateScriptAsync(admin, "Guarded", "/Guarded");
|
|
var module = await CreateFunctionAsync(admin, "Guarded", "/Guarded");
|
|
|
|
using var viewer = await SignedInWithAsync("folders-viewer", "scripts.view", "functions.view");
|
|
Assert.Contains("/Guarded", await FoldersAsync(viewer, ApiRoutes.ScriptFolders));
|
|
Assert.Contains("/Guarded", await FoldersAsync(viewer, ApiRoutes.FunctionFolders));
|
|
foreach (var (folders, move, items, id) in new[]
|
|
{
|
|
(ApiRoutes.ScriptFolders, ApiRoutes.ScriptFolderMove, ApiRoutes.ScriptsMove, script.Id),
|
|
(ApiRoutes.FunctionFolders, ApiRoutes.FunctionFolderMove, ApiRoutes.FunctionModulesMove, module.Id),
|
|
})
|
|
{
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await CreateFolderAsync(viewer, folders, "/Nope")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await DeleteFolderAsync(viewer, folders, "/Guarded")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Forbidden,
|
|
(await viewer.PostAsJsonAsync(move, new MoveFolderRequest("/Guarded", "/Moved"), JsonDefaults.Options)).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Forbidden,
|
|
(await viewer.PostAsJsonAsync(items, new MoveToFolderRequest([id], "/"), JsonDefaults.Options)).StatusCode);
|
|
}
|
|
|
|
// Each library answers to its own permissions.
|
|
using var scripter = await SignedInWithAsync("folders-scripter", "scripts.view", "scripts.manage");
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await scripter.GetAsync(ApiRoutes.FunctionFolders)).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await CreateFolderAsync(scripter, ApiRoutes.FunctionFolders, "/Nope")).StatusCode);
|
|
(await CreateFolderAsync(scripter, ApiRoutes.ScriptFolders, "/Scripter")).EnsureSuccessStatusCode();
|
|
(await scripter.PostAsJsonAsync(ApiRoutes.ScriptsMove, new MoveToFolderRequest([script.Id], "/Scripter"), JsonDefaults.Options))
|
|
.EnsureSuccessStatusCode();
|
|
|
|
using var outsider = await SignedInWithAsync("folders-outsider", "devices.view");
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await outsider.GetAsync(ApiRoutes.ScriptFolders)).StatusCode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SequenceFoldersFollowTheScriptsPermissions()
|
|
{
|
|
using var admin = await fixture.SignedInAsync("folders-seq-perm-admin");
|
|
var sequence = await CreateSequenceAsync(admin, "Guarded Sequence", "/SeqGuarded");
|
|
|
|
// The built-in Viewer reads the tree but changes nothing.
|
|
using var viewer = await fixture.SignedInAsync("folders-seq-viewer", "Viewer");
|
|
Assert.Contains("/SeqGuarded", await FoldersAsync(viewer, ApiRoutes.SequenceFolders));
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await CreateFolderAsync(viewer, ApiRoutes.SequenceFolders, "/Nope")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await DeleteFolderAsync(viewer, ApiRoutes.SequenceFolders, "/SeqGuarded")).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Forbidden,
|
|
(await viewer.PostAsJsonAsync(ApiRoutes.SequenceFolderMove, new MoveFolderRequest("/SeqGuarded", "/Moved"), JsonDefaults.Options)).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Forbidden,
|
|
(await viewer.PostAsJsonAsync(ApiRoutes.SequencesMove, new MoveToFolderRequest([sequence.Id], "/"), JsonDefaults.Options)).StatusCode);
|
|
Assert.Equal("/SeqGuarded", await SequenceFolderAsync(admin, sequence.Id));
|
|
|
|
// Scripts View and Manage Scripts are enough: Functions permissions play no part.
|
|
using var scripter = await SignedInWithAsync("folders-seq-scripter", "scripts.view", "scripts.manage");
|
|
(await CreateFolderAsync(scripter, ApiRoutes.SequenceFolders, "/SeqScripter")).EnsureSuccessStatusCode();
|
|
(await scripter.PostAsJsonAsync(ApiRoutes.SequencesMove, new MoveToFolderRequest([sequence.Id], "/SeqScripter"), JsonDefaults.Options))
|
|
.EnsureSuccessStatusCode();
|
|
|
|
using var functions = await SignedInWithAsync("folders-seq-functions", "functions.view", "functions.manage");
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await functions.GetAsync(ApiRoutes.SequenceFolders)).StatusCode);
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await CreateFolderAsync(functions, ApiRoutes.SequenceFolders, "/Nope")).StatusCode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task VaultListsEveryFolderForItsTree()
|
|
{
|
|
using var admin = await fixture.SignedInAsync("folders-vault");
|
|
(await admin.PostAsJsonAsync(ApiRoutes.VaultFolders, new VaultFolderRequest("/TreeEmpty"), JsonDefaults.Options)).EnsureSuccessStatusCode();
|
|
(await admin.PostAsJsonAsync(ApiRoutes.VaultSecrets, new SaveVaultSecretRequest("/Tree/A/B", "KEY", "fake-tree-value"), JsonDefaults.Options))
|
|
.EnsureSuccessStatusCode();
|
|
|
|
var folders = await FoldersAsync(admin, ApiRoutes.VaultFolders);
|
|
Assert.Contains("/TreeEmpty", folders);
|
|
Assert.Contains("/Tree", folders);
|
|
Assert.Contains("/Tree/A", folders);
|
|
Assert.Contains("/Tree/A/B", folders);
|
|
Assert.DoesNotContain("/", folders);
|
|
|
|
using var outsider = await SignedInWithAsync("folders-vault-outsider", "scripts.view");
|
|
Assert.Equal(HttpStatusCode.Forbidden, (await outsider.GetAsync(ApiRoutes.VaultFolders)).StatusCode);
|
|
}
|
|
}
|