Add Volo.Abp.Imaging.Tests

framework/Volo.Abp.sln

@@ -447,6 +447,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.ImageSharp
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.MagickNet", "src\Volo.Abp.Imaging.MagickNet\Volo.Abp.Imaging.MagickNet.csproj", "{F701EDA5-D7EA-4AA7-9C57-83ED50CE72EC}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Imaging.Tests", "test\Volo.Abp.Imaging.Tests\Volo.Abp.Imaging.Tests.csproj", "{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -1333,6 +1335,10 @@ Global
 		{F701EDA5-D7EA-4AA7-9C57-83ED50CE72EC}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F701EDA5-D7EA-4AA7-9C57-83ED50CE72EC}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F701EDA5-D7EA-4AA7-9C57-83ED50CE72EC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -1558,6 +1564,7 @@ Global
 		{44467427-E0BE-492C-B9B4-82B362C183C3} = {5DF0E140-0513-4D0D-BE2E-3D4D85CD70E6}
 		{F701EDA5-D7EA-4AA7-9C57-83ED50CE72EC} = {5DF0E140-0513-4D0D-BE2E-3D4D85CD70E6}
 		{78340A37-219E-4F2D-9AC6-40A7B467EEEC} = {5DF0E140-0513-4D0D-BE2E-3D4D85CD70E6}
+		{2BE6BDC7-A9A3-4E30-9099-A9EF4813F6FF} = {447C8A77-E5F0-4538-8687-7383196D04EA}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {BB97ECF4-9A84-433F-A80B-2A3285BDD1D5}

framework/test/Volo.Abp.Imaging.Tests/Volo.Abp.Imaging.Abstractions.Tests.abppkg.json

@@ -0,0 +1,3 @@
+{
+  "role": "lib.test"
+}

framework/test/Volo.Abp.Imaging.Tests/Volo.Abp.Imaging.Tests.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <Import Project="..\..\..\common.test.props" />
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <RootNamespace />
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Autofac\Volo.Abp.Autofac.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Imaging.Abstractions\Volo.Abp.Imaging.Abstractions.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Imaging.ImageSharp\Volo.Abp.Imaging.ImageSharp.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Imaging.MagickNet\Volo.Abp.Imaging.MagickNet.csproj" />
+        <ProjectReference Include="..\AbpTestBase\AbpTestBase.csproj" />
+    </ItemGroup>
+    
+    <ItemGroup>
+        <EmbeddedResource Include="Volo\Abp\Imaging\Files\**" />
+    </ItemGroup>
+</Project>

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingAbstractionsTestBase.cs

@@ -0,0 +1,105 @@
+using System.Threading.Tasks;
+using Shouldly;
+using Volo.Abp.Testing;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public abstract class AbpImagingAbstractionsTestBase : AbpIntegratedTest<AbpImagingAbstractionsTestModule>
+{
+    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+    {
+        options.UseAutofac();
+    }
+}
+
+public class IIImageResizer_Tests : AbpImagingAbstractionsTestBase
+{
+    protected IImageResizer ImageResizer { get; }
+
+    public IIImageResizer_Tests()
+    {
+        ImageResizer = GetRequiredService<IImageResizer>();
+    }
+    [Fact]
+    public async Task Should_Resize_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+        
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        resizedImage.Result.ShouldBe(jpegImage);
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
+        
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        resizedImage.Result.ShouldBe(pngImage);
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
+        
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        resizedImage.Result.ShouldBe(webpImage);
+    }
+}
+
+public class IIImageCompressor_Tests : AbpImagingAbstractionsTestBase
+{
+    protected IImageCompressor ImageCompressor { get; }
+
+    public IIImageCompressor_Tests()
+    {
+        ImageCompressor = GetRequiredService<IImageCompressor>();
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
+        
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        compressedImage.Result.ShouldBe(jpegImage);
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
+        
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        compressedImage.Result.ShouldBe(pngImage);
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
+        
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Unsupported);
+        
+        compressedImage.Result.ShouldBe(webpImage);
+    }
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingAbstractionsTestModule.cs

@@ -0,0 +1,14 @@
+using Volo.Abp.Autofac;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.Imaging;
+
+[DependsOn(
+    typeof(AbpAutofacModule),
+    typeof(AbpImagingAbstractionsModule),
+    typeof(AbpTestBaseModule)
+)]
+public class AbpImagingAbstractionsTestModule : AbpModule
+{
+
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingImageSharpProviderTestBase.cs

@@ -0,0 +1,139 @@
+using System.IO;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public abstract class AbpImagingImageSharpProviderTestBase : AbpImagingImageSharpTestBase
+{
+    protected IImageCompressor ImageCompressor { get; }
+    protected IImageResizer ImageResizer { get; }
+
+    public AbpImagingImageSharpProviderTestBase()
+    {
+        ImageCompressor = GetRequiredService<IImageCompressor>();
+        ImageResizer = GetRequiredService<IImageResizer>();
+    }
+}
+
+public class ImageSharpImageCompressor_Tests : AbpImagingImageSharpProviderTestBase
+{
+    [Fact]
+    public async Task Should_Compress_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Stream_And_Byte_Array_The_Same()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var byteArr = await jpegImage.GetAllBytesAsync();
+        
+        var compressedImage1 = await ImageCompressor.CompressAsync(jpegImage);
+        var compressedImage2 = await ImageCompressor.CompressAsync(byteArr);
+        
+        compressedImage1.ShouldNotBeNull();
+        compressedImage1.State.ShouldBe(ProcessState.Done);
+        
+        compressedImage2.ShouldNotBeNull();
+        compressedImage2.State.ShouldBe(ProcessState.Done);
+        
+        compressedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        compressedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
+        
+        compressedImage1.Result.Length.ShouldBe(compressedImage2.Result.LongLength);
+        
+        compressedImage1.Result.Dispose();
+    }
+}
+
+public class ImageSharpImageResizer_Tests : AbpImagingImageSharpProviderTestBase
+{
+    [Fact]
+    public async Task Should_Resize_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
+    }
+
+    [Fact]
+    public async Task Should_Resize_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
+    }
+
+    [Fact]
+    public async Task Should_Resize_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Stream_And_Byte_Array_The_Same()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var byteArr = await jpegImage.GetAllBytesAsync();
+        
+        var resizedImage1 = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+        var resizedImage2 = await ImageResizer.ResizeAsync(byteArr, new ImageResizeArgs(100, 100));
+        
+        resizedImage1.ShouldNotBeNull();
+        resizedImage1.State.ShouldBe(ProcessState.Done);
+        
+        resizedImage2.ShouldNotBeNull();
+        resizedImage2.State.ShouldBe(ProcessState.Done);
+        
+        resizedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        resizedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
+        
+        resizedImage1.Result.Length.ShouldBe(resizedImage2.Result.LongLength);
+        
+        resizedImage1.Result.Dispose();
+    }
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingImageSharpTestBase.cs

@@ -0,0 +1,11 @@
+using Volo.Abp.Testing;
+
+namespace Volo.Abp.Imaging;
+
+public abstract class AbpImagingImageSharpTestBase : AbpIntegratedTest<AbpImagingImageSharpTestModule>
+{
+    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+    {
+        options.UseAutofac();
+    }
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingImageSharpTestModule.cs

@@ -0,0 +1,15 @@
+using Volo.Abp.Autofac;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.Imaging;
+
+[DependsOn(
+    typeof(AbpAutofacModule),
+    typeof(AbpImagingImageSharpModule),
+    typeof(AbpTestBaseModule)
+)]
+
+public class AbpImagingImageSharpTestModule : AbpModule
+{
+
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingMagickNetProviderTestBase.cs

@@ -0,0 +1,141 @@
+using System.IO;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Imaging;
+
+public abstract class AbpImagingMagickNetProviderTestBase : AbpImagingMagickNetTestBase
+{
+    protected IImageCompressor ImageCompressor { get; }
+    protected IImageResizer ImageResizer { get; }
+
+    public AbpImagingMagickNetProviderTestBase()
+    {
+        ImageCompressor = GetRequiredService<IImageCompressor>();
+        ImageResizer = GetRequiredService<IImageResizer>();
+    }
+}
+
+
+public class MagickNetImageCompressor_Tests : AbpImagingMagickNetProviderTestBase
+{
+    [Fact]
+    public async Task Should_Compress_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(jpegImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(pngImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Done);
+        compressedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
+        
+        compressedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Compress_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var compressedImage = await ImageCompressor.CompressAsync(webpImage);
+
+        compressedImage.ShouldNotBeNull();
+        compressedImage.State.ShouldBe(ProcessState.Unsupported);
+        compressedImage.Result.ShouldBe(webpImage);
+    }
+    
+    [Fact]
+    public async Task Should_Compress_Stream_And_Byte_Array_The_Same()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var compressedImage1 = await ImageCompressor.CompressAsync(jpegImage);
+        var compressedImage2 = await ImageCompressor.CompressAsync(await jpegImage.GetAllBytesAsync());
+
+        compressedImage1.ShouldNotBeNull();
+        compressedImage1.State.ShouldBe(ProcessState.Done);
+        compressedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        
+        compressedImage2.ShouldNotBeNull();
+        compressedImage2.State.ShouldBe(ProcessState.Done);
+        compressedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
+        
+        compressedImage1.Result.Length.ShouldBe(compressedImage2.Result.LongLength);
+        
+        compressedImage1.Result.Dispose();
+    }
+}
+
+public class MagickNetImageResizer_Tests : AbpImagingMagickNetProviderTestBase
+{
+    [Fact]
+    public async Task Should_Resize_Jpg()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        
+        resizedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Resize_Png()
+    {
+        await using var pngImage = ImageFileHelper.GetPngTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(pngImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(pngImage.Length);
+        
+        resizedImage.Result.Dispose();
+    }
+
+    [Fact]
+    public async Task Should_Resize_Webp()
+    {
+        await using var webpImage = ImageFileHelper.GetWebpTestFileStream();
+        var resizedImage = await ImageResizer.ResizeAsync(webpImage, new ImageResizeArgs(100, 100));
+
+        resizedImage.ShouldNotBeNull();
+        resizedImage.State.ShouldBe(ProcessState.Done);
+        resizedImage.Result.Length.ShouldBeLessThan(webpImage.Length);
+        
+        resizedImage.Result.Dispose();
+    }
+    
+    [Fact]
+    public async Task Should_Resize_Stream_And_Byte_Array_The_Same()
+    {
+        await using var jpegImage = ImageFileHelper.GetJpgTestFileStream();
+        var resizedImage1 = await ImageResizer.ResizeAsync(jpegImage, new ImageResizeArgs(100, 100));
+        var resizedImage2 = await ImageResizer.ResizeAsync(await jpegImage.GetAllBytesAsync(), new ImageResizeArgs(100, 100));
+
+        resizedImage1.ShouldNotBeNull();
+        resizedImage1.State.ShouldBe(ProcessState.Done);
+        resizedImage1.Result.Length.ShouldBeLessThan(jpegImage.Length);
+        
+        resizedImage2.ShouldNotBeNull();
+        resizedImage2.State.ShouldBe(ProcessState.Done);
+        resizedImage2.Result.LongLength.ShouldBeLessThan(jpegImage.Length);
+        
+        resizedImage1.Result.Length.ShouldBe(resizedImage2.Result.LongLength);
+        
+        resizedImage1.Result.Dispose();
+    }
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingMagickNetTestBase.cs

@@ -0,0 +1,11 @@
+using Volo.Abp.Testing;
+
+namespace Volo.Abp.Imaging;
+
+public abstract class AbpImagingMagickNetTestBase : AbpIntegratedTest<AbpImagingMagickNetTestModule>
+{
+    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+    {
+        options.UseAutofac();
+    }
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/AbpImagingMagickNetTestModule.cs

@@ -0,0 +1,14 @@
+using Volo.Abp.Autofac;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.Imaging;
+
+[DependsOn(
+    typeof(AbpAutofacModule),
+    typeof(AbpImagingMagickNetModule),
+    typeof(AbpTestBaseModule)
+)]
+public class AbpImagingMagickNetTestModule : AbpModule
+{
+
+}

framework/test/Volo.Abp.Imaging.Tests/Volo/Abp/Imaging/ImageFileHelper.cs

@@ -0,0 +1,34 @@
+using System;
+using System.IO;
+
+namespace Volo.Abp.Imaging;
+
+public static class ImageFileHelper
+{
+    public static Stream GetJpgTestFileStream()
+    {
+        return GetTestFileStream("abp.jpg");
+    }
+    
+    public static Stream GetPngTestFileStream()
+    {
+        return GetTestFileStream("abp.png");
+    }
+    
+    public static Stream GetWebpTestFileStream()
+    {
+        return GetTestFileStream("abp.webp");
+    }
+    
+    private static Stream GetTestFileStream(string fileName)
+    {
+        var assembly = typeof(ImageFileHelper).Assembly;
+        var resourceStream = assembly.GetManifestResourceStream("Volo.Abp.Imaging.Files." + fileName);
+        if (resourceStream == null)
+        {
+            throw new Exception($"File {fileName} does not exists!");
+        }
+        
+        return resourceStream;
+    }
+}