feat: fileParser validation handling

src/ServiceLayer.Mesh/FileTypes/NbssAppointmentEvents/FileParser.cs

@@ -1,6 +1,7 @@
 using CsvHelper;
 using CsvHelper.Configuration;
 using ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents.Models;
+using ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents.Validation;
 using System.Globalization;
 using System.Text;
 
@@ -56,7 +57,10 @@ public ParsedFile Parse(Stream stream)
                     break;
 
                 default:
-                    throw new InvalidOperationException($"Unknown record identifier: {recordIdentifier}");
+                    recordIdentifier ??= "No Record Identifier found";
+                    throw new FileParsingException(
+                        ErrorCodes.UnknownRecordTypeIdentifier,
+                        $"Unknown Record Identifier {recordIdentifier}");
             }
         }
 
@@ -98,7 +102,7 @@ private static FileDataRecord ParseDataRecord(CsvReader csv, List<string> column
     {
         if (columnHeadings.Count == 0)
         {
-            throw new InvalidOperationException("Field headers (NBSSAPPT_FLDS) must appear before data records.");
+            throw new FileParsingException(ErrorCodes.MissingFieldHeadings, "Field headings are missing");
         }
 
         const int dataFieldStartIndex = 1;
@@ -140,4 +144,3 @@ public FileHeaderRecordMap()
         }
     }
 }
-

src/ServiceLayer.Mesh/FileTypes/NbssAppointmentEvents/FileParsingException.cs

@@ -0,0 +1,19 @@
+namespace ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents;
+
+public class FileParsingException : Exception
+{
+    public string Code { get; }
+
+    public FileParsingException(string code, string message)
+        : base(message)
+    {
+        Code = code;
+    }
+
+    public FileParsingException(string code, string message, Exception innerException)
+        : base(message, innerException)
+    {
+        Code = code;
+    }
+}
+

src/ServiceLayer.Mesh/FileTypes/NbssAppointmentEvents/FileTransformer.cs

@@ -1,3 +1,4 @@
+using Microsoft.Extensions.Logging;
 using ServiceLayer.Data.Models;
 using ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents.Validation;
 
@@ -6,22 +7,65 @@ namespace ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents;
 public class FileTransformer(
     IFileParser fileParser,
     IValidationRunner validationRunner,
-    IStagingPersister stagingPersister)
+    IStagingPersister stagingPersister,
+    ILogger<FileTransformer> logger)
     : FileTransformerBase
 {
     protected override MeshFileType HandlesFileType => MeshFileType.NbssAppointmentEvents;
 
     public override async Task<IList<ValidationError>> TransformFileAsync(Stream stream, MeshFile metaData)
     {
-        // TODO - wrap this parsing in a try-catch and return a List<ValidationError> in case of any unforeseen parsing issues (file is totally unlike anything we expect)
-        var parsed = fileParser.Parse(stream);
+        try
+        {
+            var parsed = fileParser.Parse(stream);
+            var validationErrors = validationRunner.Validate(parsed);
+
+            if (!validationErrors.Any())
+            {
+                await stagingPersister.WriteStagedData(parsed, metaData);
+            }
 
-        var validationErrors = validationRunner.Validate(parsed);
-        if (!validationErrors.Any())
+            return validationErrors;
+        }
+        catch (FileParsingException ex)
         {
-            await stagingPersister.WriteStagedData(parsed, metaData);
+            return HandleFileParsingException(ex);
         }
+        catch (Exception ex)
+        {
+            return HandleUnexpectedException(ex, metaData);
+        }
+    }
+
+    private List<ValidationError> HandleFileParsingException(FileParsingException ex)
+    {
+        logger.LogError("File parsing failed with validation error. Code: {ErrorCode}, Message: {ErrorMessage}",
+            ex.Code, ex.Message);
+
+        return
+        [
+            new ValidationError
+            {
+                Code = ex.Code,
+                Error = ex.Message,
+                Scope = ValidationErrorScope.File
+            }
+        ];
+    }
+
+    private IList<ValidationError> HandleUnexpectedException(Exception ex, MeshFile metaData)
+    {
+        logger.LogError(ex, "System error occurred while parsing NBSS appointment file. File: {FileName}",
+            metaData.FileId);
 
-        return validationErrors;
+        return
+        [
+            new ValidationError
+            {
+                Code = ErrorCodes.UnableToParseFile,
+                Error = "Unable to parse file",
+                Scope = ValidationErrorScope.File
+            }
+        ];
     }
 }

src/ServiceLayer.Mesh/Functions/FileExtractFunction.cs

@@ -109,7 +109,7 @@ private async Task ProcessFileExtraction(MeshFile file)
 
     private async Task HandleExtractionError(MeshFile file, FileExtractQueueMessage message, Exception ex)
     {
-        logger.LogError(ex, "An exception occurred during file extraction for fileId: {fileId}", message.FileId);
+        logger.LogError(ex, "An exception occurred during file extraction for fileId: {FileId}", message.FileId);
         file.Status = MeshFileStatus.FailedExtract;
         file.LastUpdatedUtc = DateTime.UtcNow;
         await serviceLayerDbContext.SaveChangesAsync();

src/ServiceLayer.Shared/Data/Models/MeshFileType.cs

@@ -2,5 +2,6 @@ namespace ServiceLayer.Data.Models;
 
 public enum MeshFileType
 {
-    NbssAppointmentEvents
+    NbssAppointmentEvents,
+    Unknown
 }

tests/ServiceLayer.Mesh.Tests/FileTransformerTests.cs

@@ -0,0 +1,237 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using ServiceLayer.Data.Models;
+using ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents;
+using ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents.Models;
+using ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents.Validation;
+using ServiceLayer.TestUtilities;
+
+namespace ServiceLayer.Mesh.Tests.FileTypes.NbssAppointmentEvents;
+
+public class FileTransformerTests
+{
+    private readonly Mock<IFileParser> _fileParserMock = new();
+    private readonly Mock<IValidationRunner> _validationRunnerMock = new();
+    private readonly Mock<IStagingPersister> _stagingPersisterMock = new();
+    private readonly Mock<ILogger<FileTransformer>> _loggerMock = new();
+    private readonly FileTransformer _fileTransformer;
+    private readonly MeshFile _testMeshFile;
+    private readonly Stream _testStream;
+    private readonly ParsedFile parsedFile = new();
+
+    public FileTransformerTests()
+    {
+        _fileTransformer = new FileTransformer(
+            _fileParserMock.Object,
+            _validationRunnerMock.Object,
+            _stagingPersisterMock.Object,
+            _loggerMock.Object);
+
+        _testMeshFile = new MeshFile
+        {
+            FileId = "test-file-123",
+            FileType = MeshFileType.NbssAppointmentEvents,
+            MailboxId = "testMailboxId",
+            Status = MeshFileStatus.Extracted
+        };
+
+        _testStream = new MemoryStream();
+    }
+
+    [Fact]
+    public void CanHandle_NbssAppointmentEventsFileType_ReturnsTrue()
+    {
+        // Act
+        var result = _fileTransformer.CanHandle(MeshFileType.NbssAppointmentEvents);
+
+        // Assert
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void CanHandle_OtherFileType_ReturnsFalse()
+    {
+        // Act
+        var result = _fileTransformer.CanHandle(MeshFileType.Unknown);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public async Task TransformFileAsync_ValidFileWithNoValidationErrors_ParsesValidatesAndPersists()
+    {
+        // Arrange
+        var validationErrors = new List<ValidationError>();
+
+        _fileParserMock.Setup(p => p.Parse(_testStream)).Returns(parsedFile);
+        _validationRunnerMock.Setup(v => v.Validate(parsedFile)).Returns(validationErrors);
+
+        // Act
+        var result = await _fileTransformer.TransformFileAsync(_testStream, _testMeshFile);
+
+        // Assert
+        Assert.Empty(result);
+        _fileParserMock.Verify(p => p.Parse(_testStream), Times.Once);
+        _validationRunnerMock.Verify(v => v.Validate(parsedFile), Times.Once);
+        _stagingPersisterMock.Verify(s => s.WriteStagedData(parsedFile, _testMeshFile), Times.Once);
+        _loggerMock.VerifyNoLogs(LogLevel.Error);
+    }
+
+    [Fact]
+    public async Task TransformFileAsync_ValidFileWithValidationErrors_DoesNotPersistData()
+    {
+        // Arrange
+        var validationErrors = new List<ValidationError>
+        {
+            new() { Code = "TEST001", Error = "Test validation error", Scope = ValidationErrorScope.Record, RowNumber = 1 }
+        };
+
+        _fileParserMock.Setup(p => p.Parse(_testStream)).Returns(parsedFile);
+        _validationRunnerMock.Setup(v => v.Validate(parsedFile)).Returns(validationErrors);
+
+        // Act
+        var result = await _fileTransformer.TransformFileAsync(_testStream, _testMeshFile);
+
+        // Assert
+        Assert.Equal(validationErrors, result);
+        _fileParserMock.Verify(p => p.Parse(_testStream), Times.Once);
+        _validationRunnerMock.Verify(v => v.Validate(parsedFile), Times.Once);
+        _stagingPersisterMock.Verify(s => s.WriteStagedData(It.IsAny<ParsedFile>(), It.IsAny<MeshFile>()), Times.Never);
+        _loggerMock.VerifyNoLogs(LogLevel.Error);
+    }
+
+    [Fact]
+    public async Task TransformFileAsync_FileParsingExceptionThrown_ReturnsFileValidationError()
+    {
+        // Arrange
+        var fileParsingException = new FileParsingException(ErrorCodes.UnknownRecordTypeIdentifier, "Unknown record type identifier 'INVALID_TYPE'");
+
+        _fileParserMock.Setup(p => p.Parse(_testStream)).Throws(fileParsingException);
+
+        // Act
+        var result = await _fileTransformer.TransformFileAsync(_testStream, _testMeshFile);
+
+        // Assert
+        Assert.Single(result);
+        var validationError = result[0];
+        Assert.Equal(ErrorCodes.UnknownRecordTypeIdentifier, validationError.Code);
+        Assert.Equal("Unknown record type identifier 'INVALID_TYPE'", validationError.Error);
+        Assert.Equal(ValidationErrorScope.File, validationError.Scope);
+
+        _fileParserMock.Verify(p => p.Parse(_testStream), Times.Once);
+        _validationRunnerMock.Verify(v => v.Validate(It.IsAny<ParsedFile>()), Times.Never);
+        _stagingPersisterMock.Verify(s => s.WriteStagedData(It.IsAny<ParsedFile>(), It.IsAny<MeshFile>()), Times.Never);
+
+        _loggerMock.VerifyLogger(LogLevel.Error,
+            $"File parsing failed with validation error. Code: {ErrorCodes.UnknownRecordTypeIdentifier}, Message: Unknown record type identifier 'INVALID_TYPE'");
+    }
+
+    [Fact]
+    public async Task TransformFileAsync_UnexpectedExceptionThrown_ReturnsSystemValidationError()
+    {
+        // Arrange
+        var unexpectedException = new InvalidOperationException("Something went wrong");
+        _fileParserMock.Setup(p => p.Parse(_testStream)).Throws(unexpectedException);
+
+        // Act
+        var result = await _fileTransformer.TransformFileAsync(_testStream, _testMeshFile);
+
+        // Assert
+        Assert.Single(result);
+        var validationError = result[0];
+        Assert.Equal(ErrorCodes.UnableToParseFile, validationError.Code);
+        Assert.Equal("Unable to parse file", validationError.Error);
+        Assert.Equal(ValidationErrorScope.File, validationError.Scope);
+
+        _fileParserMock.Verify(p => p.Parse(_testStream), Times.Once);
+        _validationRunnerMock.Verify(v => v.Validate(It.IsAny<ParsedFile>()), Times.Never);
+        _stagingPersisterMock.Verify(s => s.WriteStagedData(It.IsAny<ParsedFile>(), It.IsAny<MeshFile>()), Times.Never);
+
+        _loggerMock.VerifyLogger(LogLevel.Error,
+            $"System error occurred while parsing NBSS appointment file. File: {_testMeshFile.FileId}",
+            ex => ex == unexpectedException);
+    }
+
+    [Fact]
+    public async Task TransformFileAsync_ValidationRunnerThrowsException_ReturnsSystemValidationError()
+    {
+        // Arrange
+        var validationException = new InvalidOperationException("Validation failed");
+
+        _fileParserMock.Setup(p => p.Parse(_testStream)).Returns(parsedFile);
+        _validationRunnerMock.Setup(v => v.Validate(parsedFile)).Throws(validationException);
+
+        // Act
+        var result = await _fileTransformer.TransformFileAsync(_testStream, _testMeshFile);
+
+        // Assert
+        Assert.Single(result);
+        var validationError = result[0];
+        Assert.Equal(ErrorCodes.UnableToParseFile, validationError.Code);
+        Assert.Equal("Unable to parse file", validationError.Error);
+        Assert.Equal(ValidationErrorScope.File, validationError.Scope);
+
+        _fileParserMock.Verify(p => p.Parse(_testStream), Times.Once);
+        _validationRunnerMock.Verify(v => v.Validate(parsedFile), Times.Once);
+        _stagingPersisterMock.Verify(s => s.WriteStagedData(It.IsAny<ParsedFile>(), It.IsAny<MeshFile>()), Times.Never);
+
+        _loggerMock.VerifyLogger(LogLevel.Error,
+            $"System error occurred while parsing NBSS appointment file. File: {_testMeshFile.FileId}",
+            ex => ex == validationException);
+    }
+
+    [Fact]
+    public async Task TransformFileAsync_StagingPersisterThrowsException_ReturnsSystemValidationError()
+    {
+        // Arrange
+        var validationErrors = new List<ValidationError>();
+        var persistException = new InvalidOperationException("Database error");
+
+        _fileParserMock.Setup(p => p.Parse(_testStream)).Returns(parsedFile);
+        _validationRunnerMock.Setup(v => v.Validate(parsedFile)).Returns(validationErrors);
+        _stagingPersisterMock.Setup(s => s.WriteStagedData(parsedFile, _testMeshFile)).ThrowsAsync(persistException);
+
+        // Act
+        var result = await _fileTransformer.TransformFileAsync(_testStream, _testMeshFile);
+
+        // Assert
+        Assert.Single(result);
+        var validationError = result[0];
+        Assert.Equal(ErrorCodes.UnableToParseFile, validationError.Code);
+        Assert.Equal("Unable to parse file", validationError.Error);
+        Assert.Equal(ValidationErrorScope.File, validationError.Scope);
+
+        _fileParserMock.Verify(p => p.Parse(_testStream), Times.Once);
+        _validationRunnerMock.Verify(v => v.Validate(parsedFile), Times.Once);
+        _stagingPersisterMock.Verify(s => s.WriteStagedData(parsedFile, _testMeshFile), Times.Once);
+
+        _loggerMock.VerifyLogger(LogLevel.Error,
+            $"System error occurred while parsing NBSS appointment file. File: {_testMeshFile.FileId}",
+            ex => ex == persistException);
+    }
+
+    [Theory]
+    [InlineData(ErrorCodes.MissingFieldHeadings, "Field headings are missing")]
+    [InlineData(ErrorCodes.UnknownRecordTypeIdentifier, "Unknown record type 'INVALID'")]
+    [InlineData("CUSTOM001", "Custom validation error")]
+    public async Task TransformFileAsync_DifferentFileParsingExceptions_ReturnsCorrectValidationErrors(string errorCode, string errorMessage)
+    {
+        // Arrange
+        var fileParsingException = new FileParsingException(errorCode, errorMessage);
+        _fileParserMock.Setup(p => p.Parse(_testStream)).Throws(fileParsingException);
+
+        // Act
+        var result = await _fileTransformer.TransformFileAsync(_testStream, _testMeshFile);
+
+        // Assert
+        Assert.Single(result);
+        var validationError = result[0];
+        Assert.Equal(errorCode, validationError.Code);
+        Assert.Equal(errorMessage, validationError.Error);
+        Assert.Equal(ValidationErrorScope.File, validationError.Scope);
+
+        _loggerMock.VerifyLogger(LogLevel.Error,
+            $"File parsing failed with validation error. Code: {errorCode}, Message: {errorMessage}");
+    }
+}