public async Task Create_should_create_events()
{
var command = new CreateAsset {
File = file, ImageInfo = image
};
var result = await sut.ExecuteAsync(CreateAssetCommand(command));
result.ShouldBeEquivalent(new AssetSavedResult(0, 0));
Assert.Equal(0, sut.Snapshot.FileVersion);
LastEvents
.ShouldHaveSameEvents(
CreateAssetEvent(new AssetCreated
{
IsImage = true,
FileName = file.FileName,
FileSize = file.FileSize,
FileVersion = 0,
MimeType = file.MimeType,
PixelWidth = image.PixelWidth,
PixelHeight = image.PixelHeight
})
);
}
public async Task Create_should_create_events_and_update_state()
{
var command = new CreateAsset {
File = file, FileHash = "NewHash"
};
var result = await PublishAsync(command);
result.ShouldBeEquivalent2(sut.Snapshot);
Assert.Equal(0, sut.Snapshot.FileVersion);
Assert.Equal(command.FileHash, sut.Snapshot.FileHash);
LastEvents
.ShouldHaveSameEvents(
CreateAssetEvent(new AssetCreated
{
FileName = file.FileName,
FileSize = file.FileSize,
FileHash = command.FileHash,
FileVersion = 0,
Metadata = new AssetMetadata(),
MimeType = file.MimeType,
Tags = new HashSet <string>(),
Slug = file.FileName.ToAssetSlug()
})
);
}
public async Task Create_should_create_domain_object()
{
var command = new CreateAsset {
AssetId = assetId, File = file
};
var context = CreateContextForCommand(command);
A.CallTo(() => tagGenerator.GenerateTags(command, A <HashSet <string> > .Ignored))
.Invokes(new Action <CreateAsset, HashSet <string> >((c, tags) =>
{
tags.Add("tag1");
tags.Add("tag2");
}));
SetupStore(0, context.ContextId);
SetupImageInfo();
await sut.HandleAsync(context);
var result = context.Result <AssetCreatedResult>();
Assert.Equal(assetId, result.Id);
Assert.Contains("tag1", result.Tags);
Assert.Contains("tag2", result.Tags);
AssertAssetHasBeenUploaded(0, context.ContextId);
AssertAssetImageChecked();
}
public async Task Create_should_create_events()
{
var command = new CreateAsset {
File = file, ImageInfo = image, FileHash = fileHash, Tags = new HashSet <string>()
};
var result = await sut.ExecuteAsync(CreateAssetCommand(command));
result.ShouldBeEquivalent(sut.Snapshot);
Assert.Equal(0, sut.Snapshot.FileVersion);
Assert.Equal(fileHash, sut.Snapshot.FileHash);
LastEvents
.ShouldHaveSameEvents(
CreateAssetEvent(new AssetCreated
{
IsImage = true,
FileName = file.FileName,
FileHash = fileHash,
FileSize = file.FileSize,
FileVersion = 0,
MimeType = file.MimeType,
PixelWidth = image.PixelWidth,
PixelHeight = image.PixelHeight,
Tags = new HashSet <string>(),
Slug = file.FileName.ToAssetSlug()
})
);
}
public async Task Should_not_add_tag_if_no_file_info()
{
var command = new CreateAsset();
await sut.EnhanceAsync(command);
Assert.Empty(command.Tags);
}
public void Should_not_add_tag_if_no_image()
{
var command = new CreateAsset();
sut.GenerateTags(command, tags);
Assert.Empty(tags);
}
public void CanCreate_should_not_throw_exception_when_added_to_root()
{
var command = new CreateAsset {
AppId = appId
};
GuardAsset.CanCreate(command);
}
public async Task CanCreate_should_not_throw_exception_when_added_to_root()
{
var command = new CreateAsset {
AppId = appId
};
await GuardAsset.CanCreate(command, assetQuery);
}
public static Task CanCreate(CreateAsset command, IAssetQueryService assetQuery)
{
Guard.NotNull(command);
return(Validate.It(() => "Cannot upload asset.", async e =>
{
await CheckPathAsync(command.ParentId, assetQuery, e);
}));
}
private void SetupTags(CreateAsset command)
{
A.CallTo(() => tagGenerator.GenerateTags(command, A <HashSet <string> > .Ignored))
.Invokes(new Action <CreateAsset, HashSet <string> >((c, tags) =>
{
tags.Add("tag1");
tags.Add("tag2");
}));
}
public static Task CanCreate(CreateAsset command, IAssetQueryService assetQuery)
{
Guard.NotNull(command, nameof(command));
return(Validate.It(async e =>
{
await CheckPathAsync(command.AppId.Id, command.ParentId, assetQuery, e);
}));
}
private async Task CreateCore(CreateAsset create)
{
if (create.Tags != null)
{
create.Tags = await NormalizeTagsAsync(create.AppId.Id, create.Tags);
}
Create(create);
}
public async Task Should_not_add_tag_if_no_image()
{
var command = new CreateAsset {
File = file
};
await sut.EnhanceAsync(command);
Assert.Empty(command.Tags);
}
private void Create(CreateAsset command)
{
Raise(command, new AssetCreated
{
MimeType = command.File.MimeType,
FileName = command.File.FileName,
FileSize = command.File.FileSize,
Slug = command.File.FileName.ToAssetSlug()
});
}
public void Should_add_file_type()
{
var command = new CreateAsset
{
File = new AssetFile("File.DOCX", "Mime", 100, () => new MemoryStream())
};
sut.GenerateTags(command, tags);
Assert.Contains("type/docx", tags);
}
public void Should_add_blob_if_without_extension()
{
var command = new CreateAsset
{
File = new AssetFile("File", "Mime", 100, () => new MemoryStream())
};
sut.GenerateTags(command, tags);
Assert.Contains("type/blob", tags);
}
public async Task Should_also_enhance_if_type_already_found()
{
var command = new CreateAsset {
File = file, Type = AssetType.Image
};
await sut.EnhanceAsync(command);
A.CallTo(() => assetThumbnailGenerator.GetImageInfoAsync(A <Stream> ._))
.MustHaveHappened();
}
public async Task Should_add_blob_if_without_extension()
{
var command = new CreateAsset
{
File = new AssetFile("File", "Mime", 100, () => new MemoryStream())
};
await sut.EnhanceAsync(command, tags);
Assert.Contains("type/blob", tags);
}
public async Task Should_add_file_type()
{
var command = new CreateAsset
{
File = new AssetFile("File.DOCX", "Mime", 100, () => new MemoryStream())
};
await sut.EnhanceAsync(command, tags);
Assert.Contains("type/docx", tags);
}
public async Task Should_add_file_type()
{
var command = new CreateAsset
{
File = new NoopAssetFile("File.DOCX")
};
await sut.EnhanceAsync(command);
Assert.Contains("type/docx", command.Tags);
}
public async Task Should_add_blob_if_without_extension()
{
var command = new CreateAsset
{
File = new NoopAssetFile("File")
};
await sut.EnhanceAsync(command);
Assert.Contains("type/blob", command.Tags);
}
public async Task CanCreate_should_throw_exception_when_folder_not_found()
{
var command = new CreateAsset {
AppId = appId, ParentId = DomainId.NewGuid()
};
A.CallTo(() => assetQuery.FindAssetFolderAsync(appId.Id, command.ParentId))
.Returns(new List <IAssetFolderEntity>());
await ValidationAssert.ThrowsAsync(() => GuardAsset.CanCreate(command, assetQuery),
new ValidationError("Asset folder does not exist.", "ParentId"));
}
public async Task <IActionResult> PostAsset(string app, [FromQuery] Guid parentId, [OpenApiIgnore] List <IFormFile> file)
{
var assetFile = await CheckAssetFileAsync(file);
var command = new CreateAsset {
File = assetFile, ParentId = parentId
};
var response = await InvokeCommandAsync(app, command);
return(CreatedAtAction(nameof(GetAsset), new { app, id = response.Id }, response));
}
public void Should_add_image_tag_if_large()
{
var command = new CreateAsset
{
ImageInfo = new ImageInfo(1200, 1400)
};
sut.GenerateTags(command, tags);
Assert.Contains("image", tags);
Assert.Contains("image/large", tags);
}
private void GenerateTags(CreateAsset createAsset)
{
if (createAsset.Tags == null)
{
createAsset.Tags = new HashSet <string>();
}
foreach (var tagGenerator in tagGenerators)
{
tagGenerator.GenerateTags(createAsset, createAsset.Tags);
}
}
public async Task Should_add_image_tag_if_svg()
{
var svg = new DelegateAssetFile("MyImage.png", "image/svg+xml", 1024, () => stream);
var command = new CreateAsset {
File = svg
};
await sut.EnhanceAsync(command);
Assert.Contains("image", command.Tags);
}
public async Task <IActionResult> PostAsset(string app, [SwaggerIgnore] List <IFormFile> file)
{
var assetFile = await CheckAssetFileAsync(file);
var command = new CreateAsset {
File = assetFile
};
var response = await InvokeCommandAsync(app, command);
return(CreatedAtAction(nameof(GetAsset), new { app, id = response.Id }, response));
}
public void Should_add_image_tag_if_medium()
{
var command = new CreateAsset
{
ImageInfo = new ImageInfo(800, 600)
};
sut.GenerateTags(command, tags);
Assert.Contains("image", tags);
Assert.Contains("image/medium", tags);
}
protected async Task On(CreateAsset command, CommandContext context)
{
await handler.CreateAsync <AssetDomainObject>(context, async c =>
{
command.ImageInfo = await assetThumbnailGenerator.GetImageInfoAsync(command.File.OpenRead());
c.Create(command);
await assetStore.UploadAsync(c.Id.ToString(), c.FileVersion, null, command.File.OpenRead());
context.Succeed(EntityCreatedResult.Create(c.Id, c.Version));
});
}
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);
}
