⏺ Migrate to DotNetStreamReference, add round-trip e2e tests, and harden compression pipeline

Swimburger · Swimburger · commit 7671d1dc5872 · 2026-03-03T18:55:09.000-05:00
- Replace BlazorDownloadFile with DotNetStreamReference + JS downloadFileFromStream
  - Add leaveOpen: true to all compression streams to eliminate ToArray() memory copy
  - Add SemaphoreSlim(4) to bound concurrent compress/decompress memory usage
  - Add 250 MB file size warning in the UI before processing
  - Fix Safari download bug: defer revokeObjectURL by 60 s
  - Add round-trip e2e tests for all 5 formats (caught real Brotli decompression bug)
  - Add compression level e2e test (SmallestSize ≤ Fastest, round-trips correctly)
  - Fix e2e test runner: build once, kill stale server cross-platform, start with --no-build
diff --git a/App.razor b/App.razor
@@ -1,6 +1,6 @@
 @using System.IO
 @using System.IO.Compression
-@inject BlazorDownloadFile.IBlazorDownloadFileService BlazorDownloadFileService
+@inject IJSRuntime JS
 @inject NavigationManager NavManager
 
 <ul class="nav nav-pills mb-4 pb-1 border-bottom" role="navigation" aria-label="Compression format">
@@ -92,6 +92,10 @@
 {
     <li class="list-group-item d-flex align-items-center gap-2 py-2">
         <span class="text-truncate flex-grow-1 small fw-medium">@file.OriginalName</span>
+        @if (file.Status == "To Process" && file.OriginalSize > WarnFileSizeBytes)
+        {
+            <small class="text-warning text-nowrap">⚠ >250 MB</small>
+        }
         @if(file.Status == "Compressing" || file.Status == "Decompressing")
         {
             <div class="spinner-grow text-primary spinner-grow-sm flex-shrink-0" role="status">
@@ -126,6 +130,8 @@
 
     private CompressionFormat _format = CompressionFormat.GZip;
     private int _dragCount;
+    private const long WarnFileSizeBytes = 250L * 1024 * 1024;
+    private static readonly SemaphoreSlim _semaphore = new(4, 4);
 
     private static string FormatSlug(CompressionFormat fmt) => fmt switch
     {
@@ -186,17 +192,17 @@
     {
         if (_format == CompressionFormat.Brotli)
         {
-            var s = new BrotliSharpLib.BrotliStream(output, CompressionMode.Compress);
+            var s = new BrotliSharpLib.BrotliStream(output, CompressionMode.Compress, true);
             s.SetQuality(ToBrotliQuality(level));
             return s;
         }
         if (_format == CompressionFormat.ZStd)
             return new ZstdSharp.CompressionStream(output, ToZstdLevel(level));
         return _format switch
         {
-            CompressionFormat.Deflate => new DeflateStream(output, level),
-            CompressionFormat.ZLib    => new ZLibStream(output, level),
-            _                         => new GZipStream(output, level)
+            CompressionFormat.Deflate => new DeflateStream(output, level, leaveOpen: true),
+            CompressionFormat.ZLib    => new ZLibStream(output, level, leaveOpen: true),
+            _                         => new GZipStream(output, level, leaveOpen: true)
         };
     }
 
@@ -252,6 +258,7 @@
         {
             BrowserFile = f,
             OriginalName = f.Name,
+            OriginalSize = f.Size,
             Status = "To Process"
         }));
     }
@@ -263,31 +270,36 @@
         {
             var task = Task.Run(async () =>
             {
-                file.Status = "Compressing";
-                file.NewName = $"{file.OriginalName}{Extension}";
-                StateHasChanged();
-
+                await _semaphore.WaitAsync();
                 try
                 {
-                    var browserFile = file.BrowserFile;
-                    file.OriginalSize = browserFile.Size;
-                    using var inputStream = browserFile.OpenReadStream(long.MaxValue);
-                    using var outputStream = new MemoryStream();
-                    using (var compressionStream = CreateCompressStream(outputStream, compressionLevel))
+                    file.Status = "Compressing";
+                    file.NewName = $"{file.OriginalName}{Extension}";
+                    StateHasChanged();
+
+                    try
                     {
-                        await inputStream.CopyToAsync(compressionStream);
+                        var browserFile = file.BrowserFile;
+                        using var inputStream = browserFile.OpenReadStream(long.MaxValue);
+                        using var outputStream = new MemoryStream();
+                        using (var compressionStream = CreateCompressStream(outputStream, compressionLevel))
+                        {
+                            await inputStream.CopyToAsync(compressionStream);
+                        }
+                        file.OutputSize = outputStream.Length;
+                        outputStream.Position = 0;
+                        using var streamRef = new DotNetStreamReference(outputStream, leaveOpen: true);
+                        await JS.InvokeVoidAsync("downloadFileFromStream", file.NewName, streamRef);
+
+                        file.Status = "Finished";
+                    }
+                    catch(Exception ex){
+                        file.Status = $"Error: {ex.Message}";
                     }
-                    var outputBytes = outputStream.ToArray();
-                    file.OutputSize = outputBytes.Length;
-                    await BlazorDownloadFileService.DownloadFile(file.NewName, outputBytes, "application/octet-stream");
 
-                    file.Status = "Finished";
-                }
-                catch(Exception ex){
-                    file.Status = $"Error: {ex.Message}";
+                    StateHasChanged();
                 }
-
-                StateHasChanged();
+                finally { _semaphore.Release(); }
             });
             tasks.Add(task);
         }
@@ -302,30 +314,50 @@
         {
             var task = Task.Run(async () =>
             {
-                file.Status = "Decompressing";
-                file.NewName = file.OriginalName.Replace(Extension, "");
-                StateHasChanged();
-
+                await _semaphore.WaitAsync();
                 try
                 {
-                    var browserFile = file.BrowserFile;
-                    file.OriginalSize = browserFile.Size;
-                    using var inputStream = browserFile.OpenReadStream(long.MaxValue);
-                    using var outputStream = new MemoryStream();
-                    using (var decompressionStream = CreateDecompressStream(inputStream))
+                    file.Status = "Decompressing";
+                    file.NewName = file.OriginalName.Replace(Extension, "");
+                    StateHasChanged();
+
+                    try
                     {
-                        await decompressionStream.CopyToAsync(outputStream);
-                    }
-                    var outputBytes = outputStream.ToArray();
-                    file.OutputSize = outputBytes.Length;
-                    await BlazorDownloadFileService.DownloadFile(file.NewName, outputBytes, "application/octet-stream");
+                        var browserFile = file.BrowserFile;
+                        using var inputStream = browserFile.OpenReadStream(long.MaxValue);
+                        using var outputStream = new MemoryStream();
+                        // BrotliSharpLib.BrotliStream.ReadAsync calls synchronous Read internally, which
+                        // fails on IBrowserFile streams (async-only). Pre-buffer the compressed input into
+                        // a MemoryStream first. This adds a copy of the compressed data in memory, but
+                        // compressed files are typically small relative to their decompressed output.
+                        if (_format == CompressionFormat.Brotli)
+                        {
+                            using var bufferedInput = new MemoryStream();
+                            await inputStream.CopyToAsync(bufferedInput);
+                            bufferedInput.Position = 0;
+                            using var s = CreateDecompressStream(bufferedInput);
+                            s.CopyTo(outputStream);
+                        }
+                        else
+                        {
+                            using (var decompressionStream = CreateDecompressStream(inputStream))
+                            {
+                                await decompressionStream.CopyToAsync(outputStream);
+                            }
+                        }
+                        file.OutputSize = outputStream.Length;
+                        outputStream.Position = 0;
+                        using var streamRef = new DotNetStreamReference(outputStream, leaveOpen: true);
+                        await JS.InvokeVoidAsync("downloadFileFromStream", file.NewName, streamRef);
 
-                    file.Status = "Finished";
-                }
-                catch(Exception ex){
-                    file.Status = $"Error: {ex.Message}";
+                        file.Status = "Finished";
+                    }
+                    catch(Exception ex){
+                        file.Status = $"Error: {ex.Message}";
+                    }
+                    StateHasChanged();
                 }
-                StateHasChanged();
+                finally { _semaphore.Release(); }
             });
             tasks.Add(task);
         }
diff --git a/BlazorDeCompressor.csproj b/BlazorDeCompressor.csproj
@@ -9,7 +9,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BlazorDownloadFile" Version="2.4.0.2" />
     <PackageReference Include="BrotliSharpLib" Version="0.3.3" />
     <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="10.0.2" />
     <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="10.0.2" PrivateAssets="all" />
diff --git a/Program.cs b/Program.cs
@@ -1,8 +1,6 @@
 using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
-using BlazorDownloadFile;
 using BlazorDeCompressor;
 
 var builder = WebAssemblyHostBuilder.CreateDefault(args);
 builder.RootComponents.Add<App>("#app");
-builder.Services.AddBlazorDownloadFile(ServiceLifetime.Scoped);
 await builder.Build().RunAsync();
diff --git a/e2e/kill-port.js b/e2e/kill-port.js
@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// Kills any process listening on the given port (cross-platform).
+const { execSync } = require('child_process');
+const port = process.argv[2];
+if (!port) { console.error('Usage: kill-port.js <port>'); process.exit(1); }
+
+try {
+  if (process.platform === 'win32') {
+    const out = execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8' });
+    const pids = [...new Set(out.trim().split('\n').map(l => l.trim().split(/\s+/).at(-1)).filter(Boolean))];
+    for (const pid of pids) execSync(`taskkill /PID ${pid} /F`, { stdio: 'ignore' });
+  } else {
+    execSync(`lsof -ti:${port} | xargs kill -9`, { stdio: 'ignore' });
+  }
+} catch {
+  // Nothing was listening — ignore
+}
diff --git a/e2e/package.json b/e2e/package.json
@@ -1,7 +1,7 @@
 {
   "name": "e2e",
   "scripts": {
-    "test": "playwright test"
+    "test": "dotnet build .. && node kill-port.js 5001 && playwright test"
   },
   "devDependencies": {
     "@playwright/test": "^1.58.2"
diff --git a/e2e/playwright.config.js b/e2e/playwright.config.js
@@ -8,10 +8,10 @@ module.exports = defineConfig({
     ignoreHTTPSErrors: true,
   },
   webServer: {
-    command: 'dotnet run --project .. --urls https://localhost:5001',
+    command: 'dotnet run --no-build --project .. --urls https://localhost:5001',
     url: 'https://localhost:5001',
-    timeout: 60000,
-    reuseExistingServer: !process.env.CI,
+    timeout: 10000,
+    reuseExistingServer: false,
     ignoreHTTPSErrors: true,
   },
 });
diff --git a/e2e/tests/app.spec.js b/e2e/tests/app.spec.js
@@ -83,6 +83,101 @@ test('decompress a file end-to-end', async ({ page }) => {
   fs.unlinkSync(gzFile);
 });
 
+// Round-trip correctness tests — one per format.
+// Each test compresses a file, decompresses the output, and asserts the content is identical.
+// Non-gzip formats navigate to *.localhost:5001, which resolves to 127.0.0.1 on macOS and
+// modern Linux (systemd-resolved) automatically — no /etc/hosts entries required.
+const roundTripFormats = [
+  { name: 'gzip',    ext: '.gz',      url: 'https://localhost:5001' },
+  { name: 'brotli',  ext: '.br',      url: 'https://brotli.localhost:5001' },
+  { name: 'deflate', ext: '.deflate', url: 'https://deflate.localhost:5001' },
+  { name: 'zlib',    ext: '.zlib',    url: 'https://zlib.localhost:5001' },
+  { name: 'zstd',    ext: '.zst',     url: 'https://zstd.localhost:5001' },
+];
+
+for (const fmt of roundTripFormats) {
+  test(`${fmt.name} round-trip: compress then decompress preserves content`, async ({ page }) => {
+    const content = `Hello from the ${fmt.name} round-trip test!`;
+    const inputFile     = path.join(os.tmpdir(), `roundtrip-${fmt.name}-in.txt`);
+    const compressedFile = path.join(os.tmpdir(), `roundtrip-${fmt.name}-in.txt${fmt.ext}`);
+    fs.writeFileSync(inputFile, content);
+
+    try {
+      await page.goto(fmt.url);
+      await page.waitForSelector('.spinner-border', { state: 'hidden', timeout: 30000 });
+
+      // Compress
+      const compressDownloadPromise = page.waitForEvent('download');
+      await page.locator('input[type="file"]').setInputFiles(inputFile);
+      await page.getByRole('button', { name: 'Compress Files' }).click();
+      const compressedDownload = await compressDownloadPromise;
+      expect(compressedDownload.suggestedFilename()).toBe(`roundtrip-${fmt.name}-in.txt${fmt.ext}`);
+      await compressedDownload.saveAs(compressedFile);
+      await expect(page.getByText('✔ Finished')).toBeVisible({ timeout: 10000 });
+
+      // Switch to decompress mode
+      await page.locator('label[for="radio-decompress"]').click();
+
+      // Decompress
+      const decompressDownloadPromise = page.waitForEvent('download');
+      await page.locator('input[type="file"]').setInputFiles(compressedFile);
+      await page.getByRole('button', { name: 'Decompress Files' }).click();
+      const decompressedDownload = await decompressDownloadPromise;
+      expect(decompressedDownload.suggestedFilename()).toBe(`roundtrip-${fmt.name}-in.txt`);
+      const decompressedPath = await decompressedDownload.path();
+      expect(fs.readFileSync(decompressedPath, 'utf-8')).toBe(content);
+    } finally {
+      if (fs.existsSync(inputFile))      fs.unlinkSync(inputFile);
+      if (fs.existsSync(compressedFile)) fs.unlinkSync(compressedFile);
+    }
+  });
+}
+
+test('SmallestSize compression produces output <= Fastest, and round-trips correctly', async ({ page }) => {
+  const content = 'A'.repeat(100000);
+  const inputFile = path.join(os.tmpdir(), 'level-test-input.txt');
+  fs.writeFileSync(inputFile, content);
+
+  const smallestFile = path.join(os.tmpdir(), 'level-test-input.txt.gz');
+
+  try {
+    // Compress at SmallestSize
+    await page.locator('label[for="radio-smallest"]').click();
+    let downloadPromise = page.waitForEvent('download');
+    await page.locator('input[type="file"]').setInputFiles(inputFile);
+    await page.getByRole('button', { name: 'Compress Files' }).click();
+    const smallestDownload = await downloadPromise;
+    await smallestDownload.saveAs(smallestFile);
+    await expect(page.getByText('✔ Finished')).toBeVisible({ timeout: 10000 });
+    const smallestSize = fs.statSync(smallestFile).size;
+
+    // Compress at Fastest (re-select file to reset list)
+    await page.locator('label[for="radio-fastest"]').click();
+    downloadPromise = page.waitForEvent('download');
+    await page.locator('input[type="file"]').setInputFiles(inputFile);
+    await page.getByRole('button', { name: 'Compress Files' }).click();
+    const fastestDownload = await downloadPromise;
+    const fastestPath = await fastestDownload.path();
+    await expect(page.getByText('✔ Finished')).toBeVisible({ timeout: 10000 });
+    const fastestSize = fs.statSync(fastestPath).size;
+
+    expect(smallestSize).toBeLessThanOrEqual(fastestSize);
+
+    // Decompress the SmallestSize output and verify round-trip
+    await page.locator('label[for="radio-decompress"]').click();
+    downloadPromise = page.waitForEvent('download');
+    await page.locator('input[type="file"]').setInputFiles(smallestFile);
+    await page.getByRole('button', { name: 'Decompress Files' }).click();
+    const decompressedDownload = await downloadPromise;
+    const decompressedPath = await decompressedDownload.path();
+    await expect(page.getByText('✔ Finished')).toBeVisible({ timeout: 10000 });
+    expect(fs.readFileSync(decompressedPath, 'utf-8')).toBe(content);
+  } finally {
+    if (fs.existsSync(inputFile))   fs.unlinkSync(inputFile);
+    if (fs.existsSync(smallestFile)) fs.unlinkSync(smallestFile);
+  }
+});
+
 // Static content (heading, title, meta, paragraph) is driven by the inline JS in index.html,
 // which reads window.compressionFormat. We spoof it here via addInitScript.
 // Blazor component behaviour (labels, file extension) uses NavigationManager and requires
diff --git a/wwwroot/index.html b/wwwroot/index.html
@@ -249,6 +249,19 @@ <h1 class="display-5 fw-bold">Online GZIP de/compressor</h1>
       setHref('link[rel="manifest"]',                          `manifest-${format}.json`);
     })();
     </script>
+    <script>
+        window.downloadFileFromStream = async (fileName, contentStreamReference) => {
+            const arrayBuffer = await contentStreamReference.arrayBuffer();
+            const blob = new Blob([arrayBuffer]);
+            const url = URL.createObjectURL(blob);
+            const anchorElement = document.createElement('a');
+            anchorElement.href = url;
+            anchorElement.download = fileName ?? '';
+            anchorElement.click();
+            anchorElement.remove();
+            setTimeout(() => URL.revokeObjectURL(url), 60000);
+        }
+    </script>
     <script src="_framework/blazor.webassembly.js"></script>
     <script>navigator.serviceWorker.register('service-worker.js');</script>
 </body>

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "e2e",`
`3`	`3`	`"scripts": {`
`4`		`- "test": "playwright test"`
	`4`	`+ "test": "dotnet build .. && node kill-port.js 5001 && playwright test"`
`5`	`5`	`},`
`6`	`6`	`"devDependencies": {`
`7`	`7`	`"@playwright/test": "^1.58.2"`