public async Task Should_throw_exception_if_moving_to_invalid_folder()
{
var parentId = DomainId.NewGuid();
var operation = Operation(CreateAssetFolder());
A.CallTo(() => assetQuery.FindAssetFolderAsync(appId.Id, parentId, A <CancellationToken> ._))
.Returns(new List <IAssetFolderEntity>());
await ValidationAssert.ThrowsAsync(() => operation.MustMoveToValidFolder(parentId),
new ValidationError("Asset folder does not exist.", "ParentId"));
}
public async Task CanMove_should_throw_exception_when_folder_not_found()
{
var command = new MoveAsset {
AppId = appId, ParentId = DomainId.NewGuid()
};
A.CallTo(() => assetQuery.FindAssetFolderAsync(appId.Id, command.ParentId))
.Returns(new List <IAssetFolderEntity>());
await ValidationAssert.ThrowsAsync(() => GuardAsset.CanMove(command, Asset(), assetQuery),
new ValidationError("Asset folder does not exist.", "ParentId"));
}
public async Task CanCreate_should_not_throw_exception_when_folder_found()
{
var command = new CreateAsset {
AppId = appId, ParentId = DomainId.NewGuid()
};
A.CallTo(() => assetQuery.FindAssetFolderAsync(appId.Id, command.ParentId))
.Returns(new List <IAssetFolderEntity> {
CreateFolder()
});
await GuardAsset.CanCreate(command, assetQuery);
}
private Task <IReadOnlyList <IAssetFolderEntity> > GetAssetPathAsync(DomainId parentId, AssetFolderScope scope)
{
if (scope == AssetFolderScope.Items)
{
return(Task.FromResult <IReadOnlyList <IAssetFolderEntity> >(ReadonlyList.Empty <IAssetFolderEntity>()));
}
return(assetQuery.FindAssetFolderAsync(Context.App.Id, parentId, HttpContext.RequestAborted));
}
public AssetFolderGrainTests()
{
A.CallTo(() => assetQuery.FindAssetFolderAsync(parentId))
.Returns(new List <IAssetFolderEntity> {
A.Fake <IAssetFolderEntity>()
});
sut = new AssetFolderGrain(Store, assetQuery, limit, A.Dummy <ISemanticLog>());
sut.ActivateAsync(Id).Wait();
}
public AssetFolderDomainObjectTests()
{
A.CallTo(() => assetQuery.FindAssetFolderAsync(AppId, parentId))
.Returns(new List <IAssetFolderEntity> {
A.Fake <IAssetFolderEntity>()
});
sut = new AssetFolderDomainObject(Store, A.Dummy <ISemanticLog>(), assetQuery);
sut.Setup(Id);
}
private static async Task CheckPathAsync(DomainId appId, DomainId parentId, IAssetQueryService assetQuery, AddValidation e)
{
if (parentId != DomainId.Empty)
{
var path = await assetQuery.FindAssetFolderAsync(appId, parentId);
if (path.Count == 0)
{
e(T.Get("assets.folderNotFound"), nameof(MoveAsset.ParentId));
}
}
}
private static async Task CheckPathAsync(Guid parentId, IAssetQueryService assetQuery, AddValidation e)
{
if (parentId != default)
{
var path = await assetQuery.FindAssetFolderAsync(parentId);
if (path.Count == 0)
{
e("Asset folder does not exist.", nameof(MoveAsset.ParentId));
}
}
}
public AssetGrainTests()
{
A.CallTo(() => assetQuery.FindAssetFolderAsync(parentId))
.Returns(new List <IAssetFolderEntity> {
A.Fake <IAssetFolderEntity>()
});
A.CallTo(() => tagService.NormalizeTagsAsync(AppId, TagGroups.Assets, A <HashSet <string> > .Ignored, A <HashSet <string> > .Ignored))
.ReturnsLazily(x => Task.FromResult(x.GetArgument <HashSet <string> >(2)?.ToDictionary(x => x) !));
sut = new AssetGrain(Store, tagService, assetQuery, limit, A.Dummy <ISemanticLog>());
sut.ActivateAsync(Id).Wait();
}
public AssetDomainObjectTests()
{
A.CallTo(() => assetQuery.FindAssetFolderAsync(AppId, parentId))
.Returns(new List <IAssetFolderEntity> {
A.Fake <IAssetFolderEntity>()
});
A.CallTo(() => tagService.NormalizeTagsAsync(AppId, TagGroups.Assets, A <HashSet <string> > ._, A <HashSet <string> > ._))
.ReturnsLazily(x => Task.FromResult(x.GetArgument <HashSet <string> >(2)?.ToDictionary(x => x) !));
sut = new AssetDomainObject(Store, A.Dummy <ISemanticLog>(), tagService, assetQuery, contentRepository);
sut.Setup(Id);
}
public async Task <IActionResult> GetAssetFolders(string app, [FromQuery] string parentId)
{
var(folders, path) = await AsyncHelper.WhenAll(
assetQuery.QueryAssetFoldersAsync(Context, parentId),
assetQuery.FindAssetFolderAsync(Context.App.Id, parentId));
var response = Deferred.Response(() =>
{
return(AssetFoldersDto.FromAssets(folders, path, Resources));
});
Response.Headers[HeaderNames.ETag] = folders.ToEtag();
return(Ok(response));
}
public async Task CanCreate_should_throw_exception_when_folder_name_not_defined()
{
var command = new CreateAssetFolder();
A.CallTo(() => assetQuery.FindAssetFolderAsync(command.ParentId))
.Returns(new List <IAssetFolderEntity>());
await ValidationAssert.ThrowsAsync(() => GuardAssetFolder.CanCreate(command, assetQuery),
new ValidationError("Folder name is required.", "FolderName"));
}
public async Task <IActionResult> GetAssetFolders(string app, [FromQuery] Guid parentId)
{
var assetFolders = assetQuery.QueryAssetFoldersAsync(Context, parentId);
var assetPath = assetQuery.FindAssetFolderAsync(parentId);
await Task.WhenAll(assetFolders, assetPath);
var response = Deferred.Response(() =>
{
return(AssetFoldersDto.FromAssets(assetFolders.Result, assetPath.Result, Resources));
});
Response.Headers[HeaderNames.ETag] = assetFolders.Result.ToEtag();
return(Ok(response));
}
public static Task CanMove(MoveAsset command, IAssetEntity asset, IAssetQueryService assetQuery)
{
Guard.NotNull(command, nameof(command));
return(Validate.It(async e =>
{
var parentId = command.ParentId;
if (parentId != asset.ParentId && parentId != DomainId.Empty && !command.OptimizeValidation)
{
var path = await assetQuery.FindAssetFolderAsync(command.AppId.Id, parentId);
if (path.Count == 0)
{
e(T.Get("assets.folderNotFound"), nameof(MoveAsset.ParentId));
}
}
}));
}
private static async Task CheckPathAsync(DomainId appId, DomainId parentId, IAssetQueryService assetQuery, DomainId id, AddValidation e)
{
if (parentId != DomainId.Empty)
{
var path = await assetQuery.FindAssetFolderAsync(appId, parentId);
if (path.Count == 0)
{
e("Asset folder does not exist.", nameof(MoveAssetFolder.ParentId));
}
else if (id != DomainId.Empty)
{
var indexOfSelf = path.IndexOf(x => x.Id == id);
var indexOfParent = path.IndexOf(x => x.Id == parentId);
if (indexOfSelf >= 0 && indexOfParent > indexOfSelf)
{
e("Cannot add folder to its own child.", nameof(MoveAssetFolder.ParentId));
}
}
}
}
private static async Task CheckPathAsync(DomainId appId, DomainId parentId, IAssetQueryService assetQuery, DomainId id, AddValidation e)
{
if (parentId != DomainId.Empty)
{
var path = await assetQuery.FindAssetFolderAsync(appId, parentId);
if (path.Count == 0)
{
e(T.Get("assets.folderNotFound"), nameof(MoveAssetFolder.ParentId));
}
else if (id != DomainId.Empty)
{
var indexOfSelf = path.IndexOf(x => x.Id == id);
var indexOfParent = path.IndexOf(x => x.Id == parentId);
if (indexOfSelf >= 0 && indexOfParent > indexOfSelf)
{
e(T.Get("assets.folderRecursion"), nameof(MoveAssetFolder.ParentId));
}
}
}
}
private static async Task CheckPathAsync(Guid parentId, IAssetQueryService assetQuery, Guid id, AddValidation e)
{
if (parentId != default)
{
var path = await assetQuery.FindAssetFolderAsync(parentId);
if (path.Count == 0)
{
e("Asset folder does not exist.", nameof(MoveAssetFolder.ParentId));
}
else if (id != default)
{
var indexOfThis = path.IndexOf(x => x.Id == id);
var indexOfParent = path.IndexOf(x => x.Id == parentId);
if (indexOfThis >= 0 && indexOfParent > indexOfThis)
{
e("Cannot add folder to its own child.", nameof(MoveAssetFolder.ParentId));
}
}
}
}
