a lot of files for tests

Author: KSemenenko

.gitignore

@@ -518,3 +518,6 @@ coverage*.info
 
 # Temporary test files
 *.tmp
+
+# Generated test asset catalog
+tests/MarkItDown.Tests/Generated/

AGENTS.md

@@ -12,6 +12,8 @@ If I tell you to remember something, you do the same, update
 - MIME handling: always use `ManagedCode.MimeTypes` for MIME constants, lookups, and validation logic.
 - Treat this repository as a high-fidelity port of `microsoft-markitdown`: every test fixture copied from the upstream `tests/test_files/` directory must be referenced by .NET tests (either as positive conversions or explicit unsupported cases). No orphaned fixtures.
 - CSV parsing must use the `Sep` library; avoid Sylvan or other CSV parsers for new or updated code.
+- Format integration tasks: never break the project or existing tests, and validate new format handling against real sample files.
+- Test fixtures must be surfaced via the auto-generated `TestAssetCatalog`; add binaries under `TestFiles/` and rely on its constants in tests.
 
 # Repository Guidelines
 

src/MarkItDown.Cli/ConversionService.cs

@@ -20,7 +20,7 @@ public async Task<ConversionSummary> ConvertFilesAsync(IReadOnlyList<string> fil
 
         Directory.CreateDirectory(outputDirectory);
         var results = new List<ConversionResult>(files.Count);
-        var markItDown = new MarkItDown(options);
+        var markItDown = new MarkItDownClient(options);
 
         for (var index = 0; index < files.Count; index++)
         {
@@ -53,7 +53,7 @@ public async Task<ConversionSummary> ConvertUrlAsync(string url, string outputDi
         }
 
         Directory.CreateDirectory(outputDirectory);
-        var markItDown = new MarkItDown(options);
+        var markItDown = new MarkItDownClient(options);
         var conversion = await markItDown.ConvertFromUrlAsync(url, cancellationToken: cancellationToken).ConfigureAwait(false);
         var outputPath = await WriteMarkdownAsync(conversion.Markdown, DeriveFileNameFromUrl(url, conversion.Title), outputDirectory, cancellationToken).ConfigureAwait(false);
         var result = new ConversionResult(url, outputPath, true, null, conversion.Segments.Count);

src/MarkItDown.Cli/MarkItDown.Cli.csproj

@@ -11,6 +11,7 @@
     <IncludeAllContentForSelfExtract>true</IncludeAllContentForSelfExtract>
     <EnableCompressionInSingleFile>true</EnableCompressionInSingleFile>
     <SelfContained Condition="'$(SelfContained)' == ''">false</SelfContained>
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>

src/MarkItDown/Converters/XlsxConverter.cs

@@ -212,37 +212,51 @@ private static string ConvertWorksheetToMarkdown(WorksheetPart worksheetPart, st
 
     private static string GetCellValue(Cell cell, SharedStringTable? stringTable)
     {
-        if (cell.CellValue == null)
-            return "";
+        var dataType = cell.DataType?.Value;
+        var cellValue = cell.CellValue?.Text;
 
-        var value = cell.CellValue.Text;
-        
-        if (cell.DataType != null && cell.DataType.Value == CellValues.SharedString)
+        if (dataType == CellValues.InlineString)
         {
-            // Look up the value in the shared string table
-            if (stringTable != null && int.TryParse(value, out var stringIndex))
+            return cell.InlineString?.InnerText ?? cell.InnerText ?? string.Empty;
+        }
+
+        if (!string.IsNullOrEmpty(cellValue))
+        {
+            if (dataType == CellValues.SharedString)
             {
-                var stringItem = stringTable.Elements<SharedStringItem>().ElementAtOrDefault(stringIndex);
-                if (stringItem != null)
+                if (stringTable != null && int.TryParse(cellValue, out var stringIndex))
                 {
-                    return stringItem.InnerText;
+                    var stringItem = stringTable.Elements<SharedStringItem>().ElementAtOrDefault(stringIndex);
+                    if (stringItem is not null)
+                    {
+                        return stringItem.InnerText;
+                    }
                 }
             }
+            else if (dataType == CellValues.Boolean)
+            {
+                return cellValue == "0" ? "FALSE" : "TRUE";
+            }
+            else if (dataType == CellValues.Date && double.TryParse(cellValue, out var dateValue))
+            {
+                return DateTime.FromOADate(dateValue).ToString("yyyy-MM-dd");
+            }
+
+            return cellValue;
         }
-        else if (cell.DataType != null && cell.DataType.Value == CellValues.Boolean)
+
+        if (cell.CellFormula is not null && !string.IsNullOrWhiteSpace(cell.CellFormula.Text))
         {
-            return value == "0" ? "FALSE" : "TRUE";
+            return "=" + cell.CellFormula.Text.Trim();
         }
-        else if (cell.DataType != null && cell.DataType.Value == CellValues.Date)
+
+        if (cell.InlineString is not null)
         {
-            if (double.TryParse(value, out var dateValue))
-            {
-                var date = DateTime.FromOADate(dateValue);
-                return date.ToString("yyyy-MM-dd");
-            }
+            return cell.InlineString.InnerText;
         }
 
-        return value ?? "";
+        var innerText = cell.InnerText;
+        return innerText ?? string.Empty;
     }
 
     private static void CreateMarkdownTable(List<List<string>> tableData, StringBuilder result)

src/MarkItDown/MarkItDownClient.cs

@@ -20,7 +20,6 @@
 using MarkItDown.Intelligence.Providers.Azure;
 using MarkItDown.Intelligence.Providers.Google;
 using MarkItDown.YouTube;
-using Microsoft.Extensions.Logging;
 
 namespace MarkItDown;
 

tests/MarkItDown.Tests/Converters/YouTubeUrlConverterTests.cs

@@ -1,10 +1,15 @@
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
 using System.Text;
+using System.Text.Json;
 using MarkItDown.Converters;
 using MarkItDown.Intelligence.Models;
 using MarkItDown.YouTube;
 using Shouldly;
 using Xunit;
+using MarkItDown.Tests;
 
 namespace MarkItDown.Tests.Converters;
 
@@ -50,6 +55,72 @@ private sealed class NullYouTubeMetadataProvider : IYouTubeMetadataProvider
         }
     }
 
+    [Fact]
+    public async Task ConvertAsync_WithRecordedMetadata_RendersVideoDetails()
+    {
+        var metadata = LoadRecordedMetadata();
+        var provider = new FixtureYouTubeMetadataProvider(metadata);
+        var converter = new YouTubeUrlConverter(provider);
+        var streamInfo = new StreamInfo(url: "https://www.youtube.com/watch?v=8hnpIIamb6k");
+
+        var result = await converter.ConvertAsync(Stream.Null, streamInfo);
+
+        result.Title.ShouldBe(metadata.Title);
+        result.Markdown.ShouldContain(metadata.Title);
+        result.Markdown.ShouldContain("Managed Code");
+        result.Markdown.ShouldContain("**Views:** 483");
+        result.Markdown.ShouldContain("SOLID Principles");
+        result.Markdown.ShouldContain("## Captions");
+        result.Segments.ShouldContain(segment => segment.Type == SegmentType.Metadata);
+        result.Segments.Count(s => s.Type == SegmentType.Audio).ShouldBe(metadata.Captions.Count);
+
+        var firstCaption = result.Segments.First(s => s.Type == SegmentType.Audio);
+        firstCaption.StartTime.ShouldBe(TimeSpan.FromSeconds(0));
+        firstCaption.Markdown.ShouldContain("SOLID principles");
+    }
+
+    private static YouTubeMetadata LoadRecordedMetadata()
+    {
+        var jsonPath = TestAssetLoader.GetAssetPath(TestAssetCatalog.YoutubeSolidPrinciplesJson);
+        using var stream = File.OpenRead(jsonPath);
+        var fixture = JsonSerializer.Deserialize<YouTubeMetadataFixture>(stream, new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true
+        });
+
+        if (fixture is null)
+        {
+            throw new InvalidOperationException("Failed to deserialize recorded YouTube metadata fixture.");
+        }
+
+        var captions = fixture.Captions.Select(c => new YouTubeCaptionSegment(
+            c.Text,
+            c.Start is not null ? TimeSpan.FromSeconds(c.Start.Value) : null,
+            c.End is not null ? TimeSpan.FromSeconds(c.End.Value) : null,
+            c.Metadata ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        )).ToList();
+
+        var thumbnails = fixture.Thumbnails.Select(uri => new Uri(uri)).ToList();
+        var additional = fixture.AdditionalMetadata ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+
+        return new YouTubeMetadata(
+            VideoId: fixture.VideoId,
+            Title: fixture.Title,
+            ChannelTitle: fixture.ChannelTitle,
+            WatchUrl: new Uri(fixture.WatchUrl),
+            ChannelUrl: new Uri(fixture.ChannelUrl),
+            Duration: fixture.DurationSeconds is not null ? TimeSpan.FromSeconds(fixture.DurationSeconds.Value) : null,
+            UploadDate: fixture.UploadDate is not null ? DateTimeOffset.Parse(fixture.UploadDate, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal) : null,
+            ViewCount: fixture.ViewCount,
+            LikeCount: fixture.LikeCount,
+            Tags: fixture.Tags ?? Array.Empty<string>(),
+            Description: fixture.Description,
+            Thumbnails: thumbnails,
+            Captions: captions,
+            AdditionalMetadata: additional
+        );
+    }
+
     private sealed class StubYouTubeMetadataProvider : IYouTubeMetadataProvider
     {
         public Task<YouTubeMetadata?> GetVideoAsync(string videoId, CancellationToken cancellationToken = default)
@@ -81,4 +152,45 @@ private sealed class StubYouTubeMetadataProvider : IYouTubeMetadataProvider
             return Task.FromResult<YouTubeMetadata?>(metadata);
         }
     }
+
+    private sealed class FixtureYouTubeMetadataProvider : IYouTubeMetadataProvider
+    {
+        private readonly YouTubeMetadata metadata;
+
+        public FixtureYouTubeMetadataProvider(YouTubeMetadata metadata)
+        {
+            this.metadata = metadata;
+        }
+
+        public Task<YouTubeMetadata?> GetVideoAsync(string videoId, CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult<YouTubeMetadata?>(metadata);
+        }
+    }
+
+    private sealed class YouTubeMetadataFixture
+    {
+        public string VideoId { get; init; } = string.Empty;
+        public string Title { get; init; } = string.Empty;
+        public string ChannelTitle { get; init; } = string.Empty;
+        public string WatchUrl { get; init; } = string.Empty;
+        public string ChannelUrl { get; init; } = string.Empty;
+        public double? DurationSeconds { get; init; }
+        public string? UploadDate { get; init; }
+        public long? ViewCount { get; init; }
+        public long? LikeCount { get; init; }
+        public IReadOnlyList<string>? Tags { get; init; }
+        public string? Description { get; init; }
+        public IReadOnlyList<string> Thumbnails { get; init; } = Array.Empty<string>();
+        public IReadOnlyList<YouTubeCaptionFixture> Captions { get; init; } = Array.Empty<YouTubeCaptionFixture>();
+        public IReadOnlyDictionary<string, string>? AdditionalMetadata { get; init; }
+    }
+
+    private sealed class YouTubeCaptionFixture
+    {
+        public string Text { get; init; } = string.Empty;
+        public double? Start { get; init; }
+        public double? End { get; init; }
+        public IReadOnlyDictionary<string, string>? Metadata { get; init; }
+    }
 }

tests/MarkItDown.Tests/DocxConverterTests.cs

@@ -45,4 +45,33 @@ public async Task ConvertAsync_DocxWithImages_ExecutesPipelineAndCapturesArtifac
         var trailing = segment.Markdown[(placeholderIndex + image.PlaceholderMarkdown!.Length)..];
         trailing.TrimStart('\r', '\n').ShouldStartWith("DOCX ENRICHED");
     }
+
+    [Fact]
+    public async Task ConvertAsync_ComplexDocx_PreservesRichContent()
+    {
+        var client = new MarkItDownClient();
+        var path = TestAssetLoader.GetAssetPath(TestAssetCatalog.ComplexDocx);
+
+        var result = await client.ConvertAsync(path);
+
+        result.Title.ShouldBe("Rich Text Formatting");
+        result.Markdown.ShouldContain("https://example.com/docs");
+        result.Markdown.ShouldContain("| Metric | Q1 | Q2 | Total |");
+        result.Markdown.ShouldContain("Equation: x^2 + y^2 = z^2");
+        result.Markdown.ShouldContain("• Bullet list item one");
+        result.Markdown.ShouldContain("![Image 1]");
+    }
+
+    [Fact]
+    public async Task ConvertAsync_BrokenDocx_RaisesFileConversionError()
+    {
+        var client = new MarkItDownClient();
+        var path = TestAssetLoader.GetAssetPath(TestAssetCatalog.BrokenDocx);
+
+        var exception = await Should.ThrowAsync<UnsupportedFormatException>(async () => await client.ConvertAsync(path));
+        exception.InnerException.ShouldNotBeNull();
+        exception.InnerException.ShouldBeOfType<AggregateException>();
+        var aggregate = (AggregateException)exception.InnerException!;
+        aggregate.InnerExceptions.ShouldContain(e => e is FileConversionException);
+    }
 }