diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 110f87a..e9f8aa8 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -17,7 +17,10 @@ jobs: - name: Setup .NET uses: actions/setup-dotnet@v4 with: - dotnet-version: 10.0.x + # 11 builds the net11.0 targets; 10 provides the runtime for the net10.0 test runs + dotnet-version: | + 10.0.x + 11.0.x - name: Install GitVersion run: dotnet tool install GitVersion.Tool --global --version 5.* diff --git a/.gitignore b/.gitignore index a8a59d9..f2f5a5e 100644 --- a/.gitignore +++ b/.gitignore @@ -360,4 +360,6 @@ MigrationBackup/ # Fody - auto-generated XML schema FodyWeavers.xsd -*.json + +# GitVersion output (generated in CI) +version_info.json diff --git a/Mimeo.DynamicUI.Blazor.Tests/Forms/ImportFormCsvTests.cs b/Mimeo.DynamicUI.Blazor.Tests/Forms/ImportFormCsvTests.cs new file mode 100644 index 0000000..cfe60fc --- /dev/null +++ b/Mimeo.DynamicUI.Blazor.Tests/Forms/ImportFormCsvTests.cs @@ -0,0 +1,261 @@ +using AwesomeAssertions; +using Bunit; +using CsvHelper; +using Microsoft.AspNetCore.Components.Forms; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Localization; +using Mimeo.DynamicUI.Blazor.Forms; +using Mimeo.DynamicUI.Blazor.Services; +using Mimeo.DynamicUI.Data; +using System.Globalization; + +namespace Mimeo.DynamicUI.Blazor.Tests.Forms +{ + /// + /// ImportForm reads CSV records through reflection (a generic helper made generic over + /// ), so these tests cover the model shapes it must handle. + /// + public class ImportFormCsvTests + { + private const string CsvContentType = "text/csv"; + + [Fact] + public async Task ImportsCsvRecordsAsInstancesOfTheImportModelType() + { + // Arrange + using var context = CreateContext(); + var service = new RecordingImportService(); + var imported = new List(); + + var form = RenderImportForm(context, service, async args => + { + await foreach (var record in args.Data) + { + imported.Add(record); + } + }); + + // Act + await UploadAsync(form, "Id,Name,Price\n1,Alpha,1.5\n2,\"Smith, Jr\",20\n"); + + // Assert + form.WaitForAssertion(() => imported.Should().HaveCount(2)); + imported.Should().AllBeOfType(); + imported.Cast().Should().BeEquivalentTo( + [ + new CsvImportModel { Id = 1, Name = "Alpha", Price = 1.5m }, + new CsvImportModel { Id = 2, Name = "Smith, Jr", Price = 20m }, + ]); + ErrorText(form).Should().BeEmpty(); + } + + [Fact] + public async Task ImportedRecordsFlowThroughTheTypedImportExportDataServiceAdapter() + { + // Arrange: the same wiring ImportExportButtons uses + using var context = CreateContext(); + var service = new RecordingImportService(); + IImportExportDataService untypedService = service; + + var form = RenderImportForm(context, service, untypedService.ImportData); + + // Act + await UploadAsync(form, "Id,Name,Price\n1,Alpha,1.5\n"); + + // Assert + form.WaitForAssertion(() => service.Imported.Should().ContainSingle()); + service.Imported[0].Should().BeEquivalentTo(new CsvImportModel { Id = 1, Name = "Alpha", Price = 1.5m }); + } + + [Fact] + public async Task ImportsStructModels() + { + // Arrange: CsvHelper supports [CsvRecord] structs, but IAsyncEnumerable is only covariant for reference types + using var context = CreateContext(); + var service = new RecordingImportService(); + IImportExportDataService untypedService = service; + + var form = RenderImportForm(context, service, untypedService.ImportData); + + // Act + await UploadAsync(form, "Id,Name\n1,Alpha\n2,Beta\n"); + + // Assert + form.WaitForAssertion(() => ErrorText(form).Should().BeEmpty()); + form.WaitForAssertion(() => service.Imported.Should().Equal( + new CsvImportStruct { Id = 1, Name = "Alpha" }, + new CsvImportStruct { Id = 2, Name = "Beta" })); + } + + [Fact] + public async Task ImportHonorsCsvRecordMapOfAModelThatCannotBeAnnotated() + { + // Arrange: replacement for the removed CsvImportClassMapType + using var context = CreateContext(); + var service = new RecordingImportService(); + IImportExportDataService untypedService = service; + + var form = RenderImportForm(context, service, untypedService.ImportData); + + // Act + await UploadAsync(form, "Identifier,Name\n7,Alpha\n"); + + // Assert + form.WaitForAssertion(() => service.Imported.Should().ContainSingle()); + service.Imported[0].Should().BeEquivalentTo(new MappedImportModel { Id = 7, Name = "Alpha", Secret = null }); + } + + [Fact] + public async Task ImportUsesInvariantCultureRegardlessOfCurrentCulture() + { + // Arrange: de-DE would read "1.5" as 15 + var originalCulture = CultureInfo.CurrentCulture; + CultureInfo.CurrentCulture = new CultureInfo("de-DE"); + try + { + using var context = CreateContext(); + var service = new RecordingImportService(); + IImportExportDataService untypedService = service; + + var form = RenderImportForm(context, service, untypedService.ImportData); + + // Act + await UploadAsync(form, "Id,Name,Price\n1,Alpha,1.5\n"); + + // Assert + form.WaitForAssertion(() => service.Imported.Should().ContainSingle()); + service.Imported[0].Price.Should().Be(1.5m); + } + finally + { + CultureInfo.CurrentCulture = originalCulture; + } + } + + [Fact] + public async Task ShowsAnErrorWhenAColumnIsMissing() + { + // Arrange + using var context = CreateContext(); + var service = new RecordingImportService(); + IImportExportDataService untypedService = service; + + var form = RenderImportForm(context, service, untypedService.ImportData); + + // Act + await UploadAsync(form, "Id,Name\n1,Alpha\n"); + + // Assert + form.WaitForAssertion(() => ErrorText(form).Should().Contain("Price")); + service.Imported.Should().BeEmpty(); + } + + [Fact] + public async Task ShowsAnErrorWhenTheModelHasNoCsvMapping() + { + // Arrange: CsvHelper 34 can only read [CsvRecord] or [CsvRecordMap] types + using var context = CreateContext(); + var service = new RecordingImportService(); + IImportExportDataService untypedService = service; + + var form = RenderImportForm(context, service, untypedService.ImportData); + + // Act + await UploadAsync(form, "Id\n1\n"); + + // Assert + form.WaitForAssertion(() => ErrorText(form).Should().Contain(nameof(UnmappedImportModel))); + service.Imported.Should().BeEmpty(); + } + + private static BunitContext CreateContext() + { + var context = new BunitContext(); + context.JSInterop.Mode = JSRuntimeMode.Loose; + context.Services.AddSingleton(); + context.Services.AddSingleton(); + return context; + } + + private static IRenderedComponent RenderImportForm( + BunitContext context, + IImportExportDataService service, + Func, Task> onImport) + { + return context.Render(parameters => parameters + .Add(p => p.ImportExportDataService, service) + .Add(p => p.OnImport, onImport)); + } + + private static async Task UploadAsync(IRenderedComponent form, string csv) + { + var inputFile = form.FindComponent(); + await form.InvokeAsync(() => inputFile.UploadFiles(InputFileContent.CreateFromText(csv, "import.csv", contentType: CsvContentType))); + } + + private static string ErrorText(IRenderedComponent form) => + form.Find(".alert-danger").TextContent.Trim(); + + private sealed class RecordingImportService : IImportExportDataService + { + public List Imported { get; } = []; + + public async Task ImportData(ImportEventArgs args) + { + await foreach (var record in args.Data) + { + Imported.Add(record); + } + } + + public Task> GetExportModels(DataQuery args) => + Task.FromResult(new DataResponse { Count = 0, Value = [] }); + } + + private sealed class KeyStringLocalizer : IStringLocalizer + { + public LocalizedString this[string name] => new(name, name); + + public LocalizedString this[string name, params object[] arguments] => new(name, name); + + public IEnumerable GetAllStrings(bool includeParentCultures) => []; + } + } + + [CsvRecord] + public partial class CsvImportModel + { + public int Id { get; set; } + public string? Name { get; set; } + public decimal Price { get; set; } + } + + [CsvRecord] + public partial struct CsvImportStruct + { + public int Id { get; set; } + public string? Name { get; set; } + } + + public class MappedImportModel + { + public int Id { get; set; } + public string? Name { get; set; } + public string? Secret { get; set; } + } + + [CsvRecordMap(typeof(MappedImportModel))] + public partial class MappedImportModelMap + { + [CsvColumn("Identifier")] + public int Id { get; set; } + + [CsvIgnore] + public string? Secret { get; set; } + } + + public class UnmappedImportModel + { + public int Id { get; set; } + } +} diff --git a/Mimeo.DynamicUI.Blazor.Tests/Mimeo.DynamicUI.Blazor.Tests.csproj b/Mimeo.DynamicUI.Blazor.Tests/Mimeo.DynamicUI.Blazor.Tests.csproj index 9827733..9bb6d72 100644 --- a/Mimeo.DynamicUI.Blazor.Tests/Mimeo.DynamicUI.Blazor.Tests.csproj +++ b/Mimeo.DynamicUI.Blazor.Tests/Mimeo.DynamicUI.Blazor.Tests.csproj @@ -1,28 +1,22 @@ - net10.0 + net10.0;net11.0 enable enable false true + Exe + true - - - + + + - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - + diff --git a/Mimeo.DynamicUI.Blazor/Controls/DataSourceDropDownGrid.razor.cs b/Mimeo.DynamicUI.Blazor/Controls/DataSourceDropDownGrid.razor.cs index 35bbe51..9eea420 100644 --- a/Mimeo.DynamicUI.Blazor/Controls/DataSourceDropDownGrid.razor.cs +++ b/Mimeo.DynamicUI.Blazor/Controls/DataSourceDropDownGrid.razor.cs @@ -139,7 +139,6 @@ private async Task OnGridLoadData(LoadDataArgs args) } isLoading = true; - StateHasChanged(); try { @@ -210,7 +209,6 @@ private async Task OnGridLoadData(LoadDataArgs args) finally { isLoading = false; - StateHasChanged(); } } diff --git a/Mimeo.DynamicUI.Blazor/Forms/DynamicEditForm.razor b/Mimeo.DynamicUI.Blazor/Forms/DynamicEditForm.razor index 9effcd4..3355034 100644 --- a/Mimeo.DynamicUI.Blazor/Forms/DynamicEditForm.razor +++ b/Mimeo.DynamicUI.Blazor/Forms/DynamicEditForm.razor @@ -122,7 +122,11 @@ private async Task SubmitEventHandler() { +#if NET11_0_OR_GREATER + if (Context != null && await Context.ValidateAsync() == true) +#else if (Context?.Validate() == true) +#endif { ErrorMessage = ""; try diff --git a/Mimeo.DynamicUI.Blazor/Forms/ImportExportButtons.razor b/Mimeo.DynamicUI.Blazor/Forms/ImportExportButtons.razor index c9a7617..a42ecff 100644 --- a/Mimeo.DynamicUI.Blazor/Forms/ImportExportButtons.razor +++ b/Mimeo.DynamicUI.Blazor/Forms/ImportExportButtons.razor @@ -1,8 +1,10 @@ -@using Mimeo.DynamicUI.Blazor.Extensions +@using Microsoft.Extensions.Logging +@using Mimeo.DynamicUI.Blazor.Extensions @inject DialogService dialogService @inject TaskRunningService taskRunningService @inject IJSRuntime JSRuntime +@inject ILogger logger @{ RenderFragment exportFragment; @@ -66,7 +68,24 @@ var extension = dataType.ToString("f").ToLower(); // This works for CSV and JSON. In the future we might need to tweak things. var fileName = $"export-{DateTime.Now.ToString("o").Replace(":", "_")}.{extension}"; - await JSRuntime.InvokeVoidAsync("exportHelpers.downloadFile", fileName, $"text/{extension}", file); + + try + { + await JSRuntime.InvokeVoidAsync("exportHelpers.downloadFile", fileName, $"text/{extension}", file); + } + catch (JSDisconnectedException) + { + // User navigated away or closed the tab; safe to ignore. + } + catch (TaskCanceledException) + { + // Interop timed out or was canceled during component disposal. + } + catch (JSException ex) + { + // Actual bug or runtime error in the JS function; log it without crashing the circuit. + logger.LogWarning(ex, "Failed to execute exportHelpers.downloadFile JS interop."); + } }); } diff --git a/Mimeo.DynamicUI.Blazor/Forms/ImportForm.razor b/Mimeo.DynamicUI.Blazor/Forms/ImportForm.razor index 74be094..0a64064 100644 --- a/Mimeo.DynamicUI.Blazor/Forms/ImportForm.razor +++ b/Mimeo.DynamicUI.Blazor/Forms/ImportForm.razor @@ -1,9 +1,8 @@ -@using CsvHelper -@using CsvHelper.Configuration -@using System.Collections +@using System.Collections @using System.Diagnostics -@using System.Globalization +@using System.Reflection @using System.Text +@using CsvHelper @using Mimeo.DynamicUI.Blazor.Extensions @implements IDisposable @@ -93,12 +92,12 @@ { ErrorMessage = string.Empty; - var configuration = new CsvConfiguration(CultureInfo.InvariantCulture) - { - Encoding = Encoding.UTF8, - Delimiter = ",", - HasHeaderRecord = true - }; + var configuration = new CsvReaderOptions + { + Encoding = Encoding.UTF8, + Separator = ',', + HasHeader = true + }; try { @@ -109,7 +108,7 @@ void refreshProgress() { importTimeElapsed = stopwatch.Elapsed; - StateHasChanged(); + _ = InvokeAsync(StateHasChanged); if (importedCount == 0) { @@ -129,7 +128,7 @@ var timePerImport = importTimeElapsedDuringLastImportReport / importedCount; estimatedTimeRemaining = timePerImport * (estimatedTotalCount - importedCount); - StateHasChanged(); + _ = InvokeAsync(StateHasChanged); } void onImportedCountChanged(int importedCount) @@ -140,16 +139,13 @@ } using var textReader = new StreamReader(stream, Encoding.UTF8); - using var csv = new CsvReader(textReader, configuration); - - if (ImportExportDataService.CsvImportClassMapType is not null) - { - csv.Context.RegisterClassMap(ImportExportDataService.CsvImportClassMapType); - } + using var csv = CsvReader.Create(textReader, configuration); - var data = csv.GetRecordsAsync(ImportExportDataService.GetImportModelType(ImportExportDataType.CSV)); + // ReadCsvRecords(csv), where T is our import model type + var modelType = ImportExportDataService.GetImportModelType(ImportExportDataType.CSV); + var records = (IAsyncEnumerable)readCsvRecordsMethod.MakeGenericMethod(modelType).Invoke(null, [csv])!; - var args = new ImportEventArgs(data); + var args = new ImportEventArgs(records); args.OnImportedCountChanged += onImportedCountChanged; var backgroundRefreshTimer = new Timer(_ => refreshProgress(), null, 0, 1000); @@ -173,6 +169,19 @@ } } + private static readonly MethodInfo readCsvRecordsMethod = + typeof(ImportForm).GetMethod(nameof(ReadCsvRecords), BindingFlags.NonPublic | BindingFlags.Static)!; + + // Calls GetRecordsAsync directly rather than finding it by reflection, so the trimmer keeps it, + // and boxes each record so struct models work (IAsyncEnumerable is only covariant for reference types) + private static async IAsyncEnumerable ReadCsvRecords(CsvReader csv) + { + await foreach (var record in csv.GetRecordsAsync()) + { + yield return record; + } + } + private async Task ImportJson(InputFileChangeEventArgs e) { ErrorMessage = string.Empty; @@ -186,7 +195,7 @@ void refreshProgress() { importTimeElapsed = stopwatch.Elapsed; - StateHasChanged(); + _ = InvokeAsync(StateHasChanged); if (importedCount == 0) { @@ -206,7 +215,7 @@ var timePerImport = importTimeElapsedDuringLastImportReport / importedCount; estimatedTimeRemaining = timePerImport * (estimatedTotalCount - importedCount); - StateHasChanged(); + _ = InvokeAsync(StateHasChanged); } void onImportedCountChanged(int importedCount) @@ -252,7 +261,7 @@ private void OnTaskRunningChanged(bool isRunning) { taskRunning = isRunning; - StateHasChanged(); + _ = InvokeAsync(StateHasChanged); } public void Dispose() diff --git a/Mimeo.DynamicUI.Blazor/Mimeo.DynamicUI.Blazor.csproj b/Mimeo.DynamicUI.Blazor/Mimeo.DynamicUI.Blazor.csproj index dc58fa1..66ed245 100644 --- a/Mimeo.DynamicUI.Blazor/Mimeo.DynamicUI.Blazor.csproj +++ b/Mimeo.DynamicUI.Blazor/Mimeo.DynamicUI.Blazor.csproj @@ -1,7 +1,7 @@ - net10.0 + net10.0;net11.0 enable enable README.md @@ -21,16 +21,26 @@ - + - - - - - + + + + + + + + + + + + + + + diff --git a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Client/Mimeo.DynamicUI.Demo.Client.csproj b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Client/Mimeo.DynamicUI.Demo.Client.csproj index c1d4672..44e9474 100644 --- a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Client/Mimeo.DynamicUI.Demo.Client.csproj +++ b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Client/Mimeo.DynamicUI.Demo.Client.csproj @@ -1,7 +1,7 @@  - net10.0 + net11.0 enable enable true @@ -9,9 +9,9 @@ - - - + + + diff --git a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Server/Mimeo.DynamicUI.Demo.Server.csproj b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Server/Mimeo.DynamicUI.Demo.Server.csproj index 04f7308..eaefb84 100644 --- a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Server/Mimeo.DynamicUI.Demo.Server.csproj +++ b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Server/Mimeo.DynamicUI.Demo.Server.csproj @@ -1,7 +1,7 @@  - net10.0 + net11.0 enable enable @@ -9,7 +9,7 @@ - + diff --git a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Server/Program.cs b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Server/Program.cs index 0a09e8f..a2d0917 100644 --- a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Server/Program.cs +++ b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Server/Program.cs @@ -19,16 +19,10 @@ public static void Main(string[] args) var app = builder.Build(); // Configure the HTTP request pipeline. - if (app.Environment.IsDevelopment()) - { - app.UseWebAssemblyDebugging(); - } - else - { - app.UseExceptionHandler("/Error"); - // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. - app.UseHsts(); - } + app.UseExceptionHandler("/Error"); + + // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. + app.UseHsts(); app.UseHttpsRedirection(); diff --git a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Mimeo.DynamicUI.Demo.Shared.csproj b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Mimeo.DynamicUI.Demo.Shared.csproj index 3d01bae..e8b2169 100644 --- a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Mimeo.DynamicUI.Demo.Shared.csproj +++ b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Mimeo.DynamicUI.Demo.Shared.csproj @@ -1,7 +1,7 @@  - net10.0 + net11.0 enable enable diff --git a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Models/JsonCsvConverter.cs b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Models/JsonCsvConverter.cs new file mode 100644 index 0000000..345fcdd --- /dev/null +++ b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Models/JsonCsvConverter.cs @@ -0,0 +1,23 @@ +using CsvHelper; +using System.Text.Json; + +namespace Mimeo.DynamicUI.Demo.Shared.Models +{ + /// + /// Stores a value that has no fixed number of CSV columns, such as a list, as JSON in a single field. + /// An empty field reads as null. + /// + public sealed class JsonCsvConverter : ICsvConverter + { + public T Read(CsvReader reader, int index) + { + var field = reader.GetString(index); + return string.IsNullOrEmpty(field) ? default! : JsonSerializer.Deserialize(field)!; + } + + public void Write(CsvWriter writer, T value) + { + writer.WriteField(value is null ? string.Empty : JsonSerializer.Serialize(value)); + } + } +} diff --git a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Models/TestModel.cs b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Models/TestModel.cs index d0d9126..a1cadbf 100644 --- a/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Models/TestModel.cs +++ b/Mimeo.DynamicUI.Demo/Mimeo.DynamicUI.Demo.Shared/Models/TestModel.cs @@ -1,6 +1,9 @@ -namespace Mimeo.DynamicUI.Demo.Shared.Models +using CsvHelper; + +namespace Mimeo.DynamicUI.Demo.Shared.Models { - public class TestModel + [CsvRecord] + public partial class TestModel { public Guid Id { get; set; } public string? Name { get; set; } @@ -13,22 +16,31 @@ public class TestModel public DateTimeOffset DateTimeOffset { get; set; } public TimeSpan Time { get; set; } public string? SingleSelect { get; set; } + [CsvConverter(typeof(JsonCsvConverter>))] public List MultiSelect { get; set; } = new(); public string? ComboBox { get; set; } public string? Color { get; set; } + [CsvColumn(Prefix = "Section.")] public SubModelSimple Section { get; set; } = new(); + [CsvConverter(typeof(JsonCsvConverter>))] public List StringList { get; set; } = new(); + + // Lists of objects have no flat CSV representation; they round-trip through JSON import/export only + [CsvIgnore] public List SimpleModelList { get; set; } = new(); + [CsvIgnore] public List AdvancedModelList { get; set; } = new(); public string? NullableString { get; set; } public bool Enabled { get; set; } public bool EnableHiddenProperties { get; set; } public string? HiddenString { get; set; } public Guid? RelatedModelId { get; set; } + [CsvConverter(typeof(JsonCsvConverter>))] public List? RelatedModelIds { get; set; } public int CustomFormField { get; set; } - public class SubModelSimple + [CsvRecord] + public partial class SubModelSimple { public string? Property1 { get; set; } public int Property2 { get; set; } diff --git a/Mimeo.DynamicUI.Tests/Data/ImportExportDataServiceCsvExportTests.cs b/Mimeo.DynamicUI.Tests/Data/ImportExportDataServiceCsvExportTests.cs new file mode 100644 index 0000000..ca24c5b --- /dev/null +++ b/Mimeo.DynamicUI.Tests/Data/ImportExportDataServiceCsvExportTests.cs @@ -0,0 +1,189 @@ +using AwesomeAssertions; +using CsvHelper; +using Mimeo.DynamicUI.Data; +using System.Globalization; +using System.Text; + +namespace Mimeo.DynamicUI.Tests.Data +{ + public class ImportExportDataServiceCsvExportTests + { + [Fact] + public async Task ExportsCsvRecordModelWithHeaderAndRows() + { + // Arrange + IImportExportDataService service = new TestExportService( + [ + new CsvExportModel { Id = 1, Name = "Alpha", Price = 1.5m }, + new CsvExportModel { Id = 2, Name = "Beta", Price = 20m }, + ]); + + // Act + var csv = await ExportCsvAsync(service); + + // Assert + ReadLines(csv).Should().Equal( + "Id,Name,Price", + "1,Alpha,1.5", + "2,Beta,20"); + } + + [Fact] + public async Task ExportsEveryPageOfResults() + { + // Arrange + var models = Enumerable.Range(1, 7) + .Select(i => new CsvExportModel { Id = i, Name = $"Item {i}", Price = i }) + .ToList(); + IImportExportDataService service = new TestExportService(models); + + // Act: a page size of 3 means 3 pages, the last one partial + var csv = await ExportCsvAsync(service, new DataQuery { Top = 3 }); + + // Assert + var lines = ReadLines(csv); + lines.Should().HaveCount(1 + models.Count); + lines.Skip(1).Select(l => l.Split(',')[0]).Should().Equal(models.Select(m => m.Id.ToString(CultureInfo.InvariantCulture))); + } + + [Fact] + public async Task QuotesFieldsThatContainSeparatorsQuotesAndNewLines() + { + // Arrange + IImportExportDataService service = new TestExportService( + [ + new CsvExportModel { Id = 1, Name = "Smith, \"Jr\"\nSecond line", Price = 0m }, + ]); + + // Act + var csv = await ExportCsvAsync(service); + + // Assert: reading it back gives the original value + using var reader = CsvReader.FromText(csv); + var records = reader.GetRecords().ToList(); + records.Should().ContainSingle().Which.Name.Should().Be("Smith, \"Jr\"\nSecond line"); + } + + [Fact] + public async Task ExportUsesInvariantCultureRegardlessOfCurrentCulture() + { + // Arrange: de-DE writes 1.5 as "1,5", which would break the CSV columns + var originalCulture = CultureInfo.CurrentCulture; + CultureInfo.CurrentCulture = new CultureInfo("de-DE"); + try + { + IImportExportDataService service = new TestExportService( + [ + new CsvExportModel { Id = 1, Name = "Alpha", Price = 1234.5m }, + ]); + + // Act + var csv = await ExportCsvAsync(service); + + // Assert + ReadLines(csv)[1].Should().Be("1,Alpha,1234.5"); + } + finally + { + CultureInfo.CurrentCulture = originalCulture; + } + } + + [Fact] + public async Task ExportOfNoRecordsProducesNoDataRows() + { + // Arrange + IImportExportDataService service = new TestExportService([]); + + // Act + var csv = await ExportCsvAsync(service); + + // Assert + ReadLines(csv).Where(l => l != "Id,Name,Price").Should().BeEmpty(); + } + + [Fact] + public async Task ExportHonorsCsvRecordMapOfAModelThatCannotBeAnnotated() + { + // Arrange: replacement for the removed CsvExportClassMapType + IImportExportDataService service = new TestExportService( + [ + new MappedExportModel { Id = 1, Name = "Alpha", Secret = "hidden" }, + ]); + + // Act + var csv = await ExportCsvAsync(service); + + // Assert + ReadLines(csv).Should().Equal( + "Identifier,Name", + "1,Alpha"); + } + + [Fact] + public async Task ExportOfModelWithoutCsvMappingFailsWithInvalidOperationException() + { + // Arrange: CsvHelper 34 can only write [CsvRecord] or [CsvRecordMap] types + IImportExportDataService service = new TestExportService( + [ + new UnmappedExportModel { Id = 1 }, + ]); + + // Act + var act = () => ExportCsvAsync(service); + + // Assert + await act.Should().ThrowAsync(); + } + + private static async Task ExportCsvAsync(IImportExportDataService service, DataQuery? query = null) + { + var bytes = await service.ExportData(ImportExportDataType.CSV, query ?? new DataQuery()); + return Encoding.UTF8.GetString(bytes); + } + + private static string[] ReadLines(string csv) => + csv.Split(["\r\n", "\n"], StringSplitOptions.RemoveEmptyEntries); + + private sealed class TestExportService(IReadOnlyList models) : IImportExportDataService + { + public Task> GetExportModels(DataQuery args) + { + var page = models.Skip(args.Skip ?? 0).Take(args.Top ?? int.MaxValue).ToList(); + return Task.FromResult(new DataResponse { Count = page.Count, Value = page }); + } + + public Task ImportData(ImportEventArgs args) => Task.CompletedTask; + } + } + + [CsvRecord] + public partial class CsvExportModel + { + public int Id { get; set; } + public string? Name { get; set; } + public decimal Price { get; set; } + } + + public class MappedExportModel + { + public int Id { get; set; } + public string? Name { get; set; } + public string? Secret { get; set; } + } + + [CsvRecordMap(typeof(MappedExportModel))] + public partial class MappedExportModelMap + { + [CsvColumn("Identifier")] + public int Id { get; set; } + + [CsvIgnore] + public string? Secret { get; set; } + } + + public class UnmappedExportModel + { + public int Id { get; set; } + } +} diff --git a/Mimeo.DynamicUI.Tests/Mimeo.DynamicUI.Tests.csproj b/Mimeo.DynamicUI.Tests/Mimeo.DynamicUI.Tests.csproj index 08016c4..3eb6db5 100644 --- a/Mimeo.DynamicUI.Tests/Mimeo.DynamicUI.Tests.csproj +++ b/Mimeo.DynamicUI.Tests/Mimeo.DynamicUI.Tests.csproj @@ -1,28 +1,22 @@ - net10.0 + net10.0;net11.0 enable enable false true + Exe + true - - - + + + - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - + diff --git a/Mimeo.DynamicUI/Data/IImportExportDataService.cs b/Mimeo.DynamicUI/Data/IImportExportDataService.cs index 8c7d0ae..6f44784 100644 --- a/Mimeo.DynamicUI/Data/IImportExportDataService.cs +++ b/Mimeo.DynamicUI/Data/IImportExportDataService.cs @@ -12,8 +12,12 @@ public interface IImportExportDataService { IEnumerable SupportedDataTypes { get; } + [Obsolete("Use a CsvHelper.CsvRecordMapAttribute applied to the model class instead.", error: true)] public Type? CsvImportClassMapType => null; + + [Obsolete("Use a CsvHelper.CsvRecordMapAttribute applied to the model class instead.", error: true)] public Type? CsvExportClassMapType => null; + public JsonSerializerOptions? JsonSerializerOptions => null; Type GetImportModelType(ImportExportDataType dataType); @@ -53,15 +57,13 @@ async Task IImportExportDataService.ExportData(ImportExportDataType data case ImportExportDataType.CSV: { await using var writer = new StringWriter(); - await using var csv = new CsvWriter(writer, CultureInfo.InvariantCulture); - - if (CsvExportClassMapType != null) - { - csv.Context.RegisterClassMap(CsvExportClassMapType); - } - + await using var csv = CsvWriter.Create(writer); + await csv.WriteRecordsAsync(resultsEnumerable); + // WriteRecordsAsync only writes out full buffers; flush the rest before reading the StringWriter + await csv.FlushAsync(); + var file = Encoding.UTF8.GetBytes(writer.ToString()); return file; } diff --git a/Mimeo.DynamicUI/Mimeo.DynamicUI.csproj b/Mimeo.DynamicUI/Mimeo.DynamicUI.csproj index e47c936..62f1985 100644 --- a/Mimeo.DynamicUI/Mimeo.DynamicUI.csproj +++ b/Mimeo.DynamicUI/Mimeo.DynamicUI.csproj @@ -1,24 +1,31 @@ - - net8.0;net10.0 - enable - enable - README.md - Library to help create UIs based on view models - + + net10.0;net11.0 + enable + enable + README.md + Library to help create UIs based on view models + - - - True - \ - - + + + True + \ + + - - - - - + + + + + + + + + + + + diff --git a/global.json b/global.json new file mode 100644 index 0000000..3140116 --- /dev/null +++ b/global.json @@ -0,0 +1,5 @@ +{ + "test": { + "runner": "Microsoft.Testing.Platform" + } +}