feat(10-01): create BrandingService with magic byte validation and auto-compression

- Add IBrandingService interface with ImportLogoAsync, Save/Clear/GetMspLogoAsync
- Add BrandingService: PNG/JPEG magic byte detection, rejects unsupported formats with
  descriptive error, auto-compresses files over 512 KB using WPF PresentationCore imaging
- Add BrandingServiceTests: 9 tests covering validation, rejection, compression, CRUD
- Deviation: used WPF BitmapEncoder/TransformedBitmap instead of System.Drawing.Bitmap
  (System.Drawing.Common not available without new NuGet package; WPF PresentationCore
  is in the existing stack per architectural decisions)
This commit is contained in:
Dev
2026-04-08 12:32:23 +02:00
parent 3ba574612f
commit 130386622f
3 changed files with 386 additions and 0 deletions

View File

@@ -0,0 +1,223 @@
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using SharepointToolbox.Core.Models;
using SharepointToolbox.Infrastructure.Persistence;
using SharepointToolbox.Services;
namespace SharepointToolbox.Tests.Services;
[Trait("Category", "Unit")]
public class BrandingServiceTests : IDisposable
{
private readonly string _tempRepoFile;
private readonly List<string> _tempFiles = new();
public BrandingServiceTests()
{
_tempRepoFile = Path.GetTempFileName();
File.Delete(_tempRepoFile);
}
public void Dispose()
{
if (File.Exists(_tempRepoFile)) File.Delete(_tempRepoFile);
if (File.Exists(_tempRepoFile + ".tmp")) File.Delete(_tempRepoFile + ".tmp");
foreach (var f in _tempFiles)
{
if (File.Exists(f)) File.Delete(f);
}
}
private BrandingRepository CreateRepository() => new(_tempRepoFile);
private BrandingService CreateService() => new(CreateRepository());
private string WriteTempFile(byte[] bytes)
{
var path = Path.GetTempFileName();
File.WriteAllBytes(path, bytes);
_tempFiles.Add(path);
return path;
}
// Minimal valid 1x1 PNG bytes
private static byte[] MinimalPngBytes()
{
// Full 1x1 transparent PNG (67 bytes)
return new byte[]
{
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG signature
0x00, 0x00, 0x00, 0x0D, // IHDR length
0x49, 0x48, 0x44, 0x52, // IHDR
0x00, 0x00, 0x00, 0x01, // width = 1
0x00, 0x00, 0x00, 0x01, // height = 1
0x08, 0x02, // bit depth = 8, color type = RGB
0x00, 0x00, 0x00, // compression, filter, interlace
0x90, 0x77, 0x53, 0xDE, // CRC
0x00, 0x00, 0x00, 0x0C, // IDAT length
0x49, 0x44, 0x41, 0x54, // IDAT
0x08, 0xD7, 0x63, 0xF8, 0xCF, 0xC0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, // compressed data
0xE2, 0x21, 0xBC, 0x33, // CRC
0x00, 0x00, 0x00, 0x00, // IEND length
0x49, 0x45, 0x4E, 0x44, // IEND
0xAE, 0x42, 0x60, 0x82 // CRC
};
}
// Minimal valid JPEG bytes (SOI + APP0 JFIF header + EOI)
private static byte[] MinimalJpegBytes()
{
return new byte[]
{
0xFF, 0xD8, // SOI
0xFF, 0xE0, // APP0 marker
0x00, 0x10, // length = 16
0x4A, 0x46, 0x49, 0x46, 0x00, // "JFIF\0"
0x01, 0x01, // version 1.1
0x00, // aspect ratio units = 0
0x00, 0x01, 0x00, 0x01, // X/Y density = 1
0x00, 0x00, // thumbnail size
0xFF, 0xD9 // EOI
};
}
[Fact]
public async Task ImportLogoAsync_ValidPng_ReturnsPngLogoData()
{
var service = CreateService();
var pngBytes = MinimalPngBytes();
var path = WriteTempFile(pngBytes);
var result = await service.ImportLogoAsync(path);
Assert.Equal("image/png", result.MimeType);
Assert.Equal(Convert.ToBase64String(pngBytes), result.Base64);
}
[Fact]
public async Task ImportLogoAsync_ValidJpeg_ReturnsJpegLogoData()
{
var service = CreateService();
var jpegBytes = MinimalJpegBytes();
var path = WriteTempFile(jpegBytes);
var result = await service.ImportLogoAsync(path);
Assert.Equal("image/jpeg", result.MimeType);
}
[Fact]
public async Task ImportLogoAsync_BmpFile_ThrowsInvalidDataExceptionMentioningPngAndJpg()
{
var service = CreateService();
// BMP magic bytes: 0x42 0x4D
var bmpBytes = new byte[] { 0x42, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
var path = WriteTempFile(bmpBytes);
var ex = await Assert.ThrowsAsync<InvalidDataException>(() => service.ImportLogoAsync(path));
Assert.Contains("PNG", ex.Message, StringComparison.OrdinalIgnoreCase);
Assert.Contains("JPG", ex.Message, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public async Task ImportLogoAsync_EmptyFile_ThrowsInvalidDataException()
{
var service = CreateService();
var path = WriteTempFile(Array.Empty<byte>());
await Assert.ThrowsAsync<InvalidDataException>(() => service.ImportLogoAsync(path));
}
[Fact]
public async Task ImportLogoAsync_FileUnder512KB_ReturnOriginalBytesUnmodified()
{
var service = CreateService();
var pngBytes = MinimalPngBytes();
var path = WriteTempFile(pngBytes);
var result = await service.ImportLogoAsync(path);
Assert.Equal(Convert.ToBase64String(pngBytes), result.Base64);
}
[Fact]
public async Task ImportLogoAsync_FileOver512KB_ReturnsCompressedUnder512KB()
{
var service = CreateService();
// Create a large PNG image in memory (400x400 random pixels)
var largePngPath = Path.GetTempFileName();
_tempFiles.Add(largePngPath);
using (var bmp = new Bitmap(400, 400))
{
var rng = new Random(42);
for (int y = 0; y < 400; y++)
for (int x = 0; x < 400; x++)
bmp.SetPixel(x, y, Color.FromArgb(255, rng.Next(256), rng.Next(256), rng.Next(256)));
bmp.Save(largePngPath, ImageFormat.Png);
}
var fileSize = new FileInfo(largePngPath).Length;
// PNG with random pixels should exceed 512 KB
// If not, we'll pad it
if (fileSize <= 512 * 1024)
{
// Generate a bigger image to be sure
using var bmp = new Bitmap(800, 800);
var rng = new Random(42);
for (int y = 0; y < 800; y++)
for (int x = 0; x < 800; x++)
bmp.SetPixel(x, y, Color.FromArgb(255, rng.Next(256), rng.Next(256), rng.Next(256)));
bmp.Save(largePngPath, ImageFormat.Png);
}
fileSize = new FileInfo(largePngPath).Length;
Assert.True(fileSize > 512 * 1024, $"Test setup: PNG file must be > 512 KB but was {fileSize} bytes");
var result = await service.ImportLogoAsync(largePngPath);
var decodedBytes = Convert.FromBase64String(result.Base64);
Assert.True(decodedBytes.Length <= 512 * 1024,
$"Compressed result must be <= 512 KB but was {decodedBytes.Length} bytes");
}
[Fact]
public async Task SaveMspLogoAsync_PersistsLogoInRepository()
{
var repo = CreateRepository();
var service = new BrandingService(repo);
var logo = new LogoData { Base64 = "abc123==", MimeType = "image/png" };
await service.SaveMspLogoAsync(logo);
var loaded = await repo.LoadAsync();
Assert.NotNull(loaded.MspLogo);
Assert.Equal("abc123==", loaded.MspLogo.Base64);
Assert.Equal("image/png", loaded.MspLogo.MimeType);
}
[Fact]
public async Task ClearMspLogoAsync_SetsMspLogoToNull()
{
var repo = CreateRepository();
var service = new BrandingService(repo);
var logo = new LogoData { Base64 = "abc123==", MimeType = "image/png" };
await service.SaveMspLogoAsync(logo);
await service.ClearMspLogoAsync();
var loaded = await repo.LoadAsync();
Assert.Null(loaded.MspLogo);
}
[Fact]
public async Task GetMspLogoAsync_WhenNoLogoConfigured_ReturnsNull()
{
var service = CreateService();
var result = await service.GetMspLogoAsync();
Assert.Null(result);
}
}