Feature/wait what its possible to skip validation and do that on your own (#36)

* Skipping validation on request

* Extra tests

* Extra coverage

* update the documentation

---------

Co-authored-by: Tino Klijn <tino@dotnet2web.nl>

Author: DotNet2Web

CsvCore.Specs/CsvCoreReaderSpecs.cs

@@ -202,7 +202,7 @@ public void Should_Read_Provided_Csv_File_When_Missing_A_Property_In_The_Header(
         FileHelper.DeleteTestFile(filePath);
     }
 
-    [Fact(Skip = "This test fails in the complete run, but runs succeessfully in isolation")]
+    [Fact]
     public void Should_Read_Provided_Csv_File_With_Header_Using_The_Region_Delimiter_Settings()
     {
         // Arrange
@@ -334,7 +334,7 @@ public void Should_Throw_MissingFileException_When_Trying_To_Validate_The_Input_
     public void Should_Validate_The_Input_That_Only_Contains_Valid_Data()
     {
         // Arrange
-        var filePath = Path.Combine( Directory.GetCurrentDirectory(), new Faker().System.FileName(CsvExtension));
+        var filePath = Path.Combine(Directory.GetCurrentDirectory(), new Faker().System.FileName(CsvExtension));
         var delimiter = char.Parse(CultureInfo.CurrentCulture.TextInfo.ListSeparator);
 
         var persons = new Faker<CsvContentModel>()
@@ -509,7 +509,8 @@ public void Should_Read_Provided_Csv_File_Without_Header_And_Still_Set_The_Data_
     }
 
     [Fact]
-    public void Should_Read_Provided_Csv_File_Without_Header_And_Still_Set_The_Data_On_The_Correct_Properties_Even_With_A_ZeroBasedModel()
+    public void
+        Should_Read_Provided_Csv_File_Without_Header_And_Still_Set_The_Data_On_The_Correct_Properties_Even_With_A_ZeroBasedModel()
     {
         // Arrange
         var directory = Directory.GetCurrentDirectory();
@@ -684,10 +685,12 @@ public void Should_Write_An_ErrorFile_Without_Using_The_WriteErrorsAt_Method()
     }
 
     [Theory]
-    [InlineData(@"C:\Temp\Errors")]
-    [InlineData("")]
+    [InlineData(@"C:\Temp\Errors", false)]
+    [InlineData("", false)]
+    [InlineData(@"C:\Temp\Errors", true)]
+    [InlineData("", true)]
     public void Should_Validate_The_Input_When_Reading_The_Csv_File_And_Write_An_ErrorFile_To_The_Provided_Location(
-        string errorLocation)
+        string errorLocation, bool withoutHeader)
     {
         // Arrange
         var csvCoreReader = new CsvCoreReader();
@@ -712,8 +715,15 @@ public void Should_Validate_The_Input_When_Reading_The_Csv_File_And_Write_An_Err
         invalid.BirthDate = "01-01-2023T00:00:00";
         persons.Add(invalid);
 
-        new CsvCoreWriter()
-            .UseDelimiter(delimiter)
+        var csvCoreWriter = new CsvCoreWriter();
+
+        if (withoutHeader)
+        {
+            csvCoreWriter.WithoutHeader();
+            csvCoreReader.WithoutHeader();
+        }
+
+        csvCoreWriter.UseDelimiter(delimiter)
             .Write(filePath, persons);
 
         // Act
@@ -746,7 +756,7 @@ public void Should_Validate_The_Input_When_Reading_The_Csv_File_And_Write_An_Err
     public void Should_Read_Provided_Csv_File_With_Header_When_A_DateTime_Is_Available_In_The_Data_And_Model()
     {
         // Arrange
-        var dateFormat ="yyyyMMddTHHmmss";
+        var dateFormat = "yyyyMMddTHHmmss";
 
         var csvCoreReader = new CsvCoreReader();
 
@@ -798,4 +808,82 @@ public void Should_Read_Provided_Csv_File_With_Header_When_A_DateTime_Is_Availab
         // Cleanup
         FileHelper.DeleteTestFile(filePath);
     }
+
+    [Theory]
+    [InlineData(" ", false)]
+    [InlineData("", false)]
+    [InlineData(null, false)]
+    [InlineData(" ", true)]
+    [InlineData("", true)]
+    [InlineData(null, true)]
+    public void Should_Generate_A_Full_Model_With_Invalid_Records_When_Reading_The_Csv_File_Using_SkipValidation(
+        string invalidBirthDate, bool withoutHeader)
+    {
+        // Arrange
+        var csvCoreReader = new CsvCoreReader();
+        var delimiter = char.Parse(CultureInfo.CurrentCulture.TextInfo.ListSeparator);
+
+        var directory = Directory.GetCurrentDirectory();
+        var filePath = Path.Combine(directory, new Faker().System.FileName(CsvExtension));
+
+        var persons = new Faker<CsvContentModel>()
+            .RuleFor(person => person.Name, faker => faker.Person.FirstName)
+            .RuleFor(person => person.Surname, faker => faker.Person.LastName)
+            .RuleFor(person => person.BirthDate, faker => faker.Person.DateOfBirth.ToShortDateString())
+            .RuleFor(person => person.Email, faker => faker.Internet.Email())
+            .Generate(5);
+
+        var invalid1 = new Faker<CsvContentModel>()
+            .RuleFor(person => person.Name, faker => faker.Person.FirstName)
+            .RuleFor(person => person.Surname, faker => faker.Person.LastName)
+            .RuleFor(person => person.BirthDate, _ => invalidBirthDate)
+            .RuleFor(person => person.Email, faker => faker.Internet.Email())
+            .Generate();
+
+        var invalid2 = new Faker<CsvContentModel>()
+            .RuleFor(person => person.Name, _ => null)
+            .RuleFor(person => person.Surname, faker => faker.Person.LastName)
+            .RuleFor(person => person.BirthDate, faker => faker.Person.DateOfBirth.ToShortDateString())
+            .RuleFor(person => person.Email, _ => null)
+            .Generate();
+
+        var anotherSetValidData = new Faker<CsvContentModel>()
+            .RuleFor(person => person.Name, faker => faker.Person.FirstName)
+            .RuleFor(person => person.Surname, faker => faker.Person.LastName)
+            .RuleFor(person => person.BirthDate, faker => faker.Person.DateOfBirth.ToShortDateString())
+            .RuleFor(person => person.Email, faker => faker.Internet.Email())
+            .Generate(5);
+
+        persons.Add(invalid1);
+        persons.Add(invalid2);
+        persons.AddRange(anotherSetValidData);
+
+        var csvCoreWriter = new CsvCoreWriter();
+
+        if (withoutHeader)
+        {
+            csvCoreWriter.WithoutHeader();
+        }
+
+        csvCoreWriter.UseDelimiter(delimiter).Write(filePath, persons);
+
+        if (withoutHeader)
+        {
+            csvCoreReader.WithoutHeader();
+        }
+
+        // Act
+        var result = csvCoreReader
+            .SkipValidation()
+            .Read<PersonModel>(filePath).ToList();
+
+        // Assert
+        result.Should().NotBeEmpty();
+        result.Count.Should().Be(12);
+
+        result[5].BirthDate.Should().Be(DateOnly.MinValue);
+
+        // Cleanup
+        FileHelper.DeleteTestFile(filePath);
+    }
 }

CsvCore/Documentation/CsvCoreReader.md

@@ -86,40 +86,38 @@ When you have the model all setup use the `CsvCoreReader` to read the csv file,
 
 Ofcourse you will receive csv files that are not valid, so we added some validations to the reader.
 
-If you don't want to validate the csv file before reading it, just read the file like described above.
-
 We will validate the data before adding them to the result models, any record that cant be parsed correctly will be added to errors.csv file.
 
 The file will be stored at the location your application will be run. The filename will be the same as the original file, but we just add `_errors` to it.
 
-If you need those error files to be written somewhere else simply use the `.WriteErrorsAt("AnyPath")` method on the reader
+If you need those error files to be written somewhere else simply use the `.SetErrorPath("AnyPath")` method on the reader
 
 ### Example
 
 ```csharp
     var result = csvCoreReader
         .SetErrorPath(@"C:\Temp\Errors") // your errors will be stored in here, ofcourse you would put this in a configuration file ;)
-        .Read<PersonModel>(filePath);
+        .Read<ResultModel>(Path.Combine("AnyPath", "YourFile.csv"));
 
     or
 
     var result = csvCoreReader
         .SetErrorPath() // your errors will be stored in the same location as the application is run.
-        .Read<PersonModel>(filePath);
+        .Read<ResultModel>(Path.Combine("AnyPath", "YourFile.csv"));
 
     or
 
     var result = csvCoreReader
-        .Read<PersonModel>(filePath); // your errors will be stored in the same location as the application is run.
+        .Read<ResultModel>(Path.Combine("AnyPath", "YourFile.csv")); // your errors will be stored in the same location as the application is run.
 ```
 
-If you want to validate the csv file before reading it, you can use the `IsValid` method.
+If you want to validate the csv file before reading it, you can use the `IsValid` method
 
 ### Example
 
 ```csharp
    var result = csvCoreReader
-       .IsValid<PersonModel>(filePath);
+       .IsValid<ResultModel>(filePath);
 ```
 
 The `IsValid` method will return a `List<ValidationModel>` containing:
@@ -129,18 +127,19 @@ The `IsValid` method will return a `List<ValidationModel>` containing:
 
 This could be handy in numerous ways.
 
-### Date/Time formats
-
-This is going to be a slipery slope, but we will try to make it as easy as possible.
-DateTime and/or DateOnly properties are a bit tricky, because we have to parse the data in the csv file to a DateTime or DateOnly object.
-
-We gave it a try, and we think we did a good job.
+And how about skipping the validation. If you want to skip the validation, you can use the `SkipValidation` method.
+### Example
 
-If you have a date/time format that is not the default one, you can set the format using the `SetDateTimeFormat` method.
 ```csharp
-    var result = csvCoreReader
-        .SetDateTimeFormat("dd/MM/yyyy") // Set the date format to dd/MM/yyyy
-        .Read<PersonModel>(filePath);
+   var result = csvCoreReader
+       .SkipValidation()
+       .Read<ResultModel>(Path.Combine("AnyPath", "YourFile.csv"));
 ```
-Be aware these options are always tricky so if you encounter any issues with it, please report an issue at GitHub with as much information as possible.
-A unit test example would be awesome!
+
+This will skip the validation and read the csv file without validating the data.
+The result will be a list of `ResultModel` objects, but the data will not be validated.
+
+**A litte note about the validation:**
+- _If you have a non-nullable dateonly / datetime property in your model, and the csv file contains a null value, the reader will set these properties to their MinValues._
+
+This way you can do whatever you want with the result.

CsvCore/Extensions/DateTypeExtensions.cs

@@ -12,26 +12,48 @@ public static class DateTypeExtensions
     public static bool ConvertToDateTypes<T>(this string dateTime, string? dateFormat, PropertyInfo property, T target)
         where T : class
     {
-        if (property.PropertyType == typeof(DateOnly))
-        {
-            if (string.IsNullOrEmpty(dateFormat))
-            {
-                if (Regex.IsMatch(dateTime, DateOnlyPattern))
-                {
-                    property.SetValue(target, DateOnly.Parse(dateTime, CultureInfo.CurrentCulture));
+        return SetDateOnly(dateTime, dateFormat, property, target) ||
+               SetDateTime(dateTime, dateFormat, property, target);
+    }
 
-                    return true;
-                }
-            }
+    private static bool SetDateOnly<T>(string dateTime, string? dateFormat, PropertyInfo property, T target) where T : class
+    {
+        if (property.PropertyType != typeof(DateOnly))
+        {
+            return false;
+        }
 
-            if (dateTime.ValidateDateOnly(dateFormat))
+        if (string.IsNullOrEmpty(dateFormat))
+        {
+            if (Regex.IsMatch(dateTime, DateOnlyPattern))
             {
-                property.SetValue(target, DateOnly.ParseExact(dateTime, dateFormat!, CultureInfo.CurrentCulture));
+                property.SetValue(target, DateOnly.Parse(dateTime, CultureInfo.CurrentCulture));
 
                 return true;
             }
         }
 
+        if (dateTime.ValidateDateOnly(dateFormat))
+        {
+            property.SetValue(target, DateOnly.ParseExact(dateTime, dateFormat!, CultureInfo.CurrentCulture));
+
+            return true;
+        }
+
+        if (property.PropertyType.IsGenericType &&
+            property.PropertyType.GetGenericTypeDefinition() == typeof(DateOnly?) &&
+            string.IsNullOrWhiteSpace(dateTime))
+        {
+            property.SetValue(target, null);
+            return true;
+        }
+
+        property.SetValue(target, DateOnly.MinValue);
+        return true;
+    }
+
+    private static bool SetDateTime<T>(string dateTime, string? dateFormat, PropertyInfo property, T target) where T : class
+    {
         if (property.PropertyType != typeof(DateTime))
         {
             return false;
@@ -47,16 +69,27 @@ public static bool ConvertToDateTypes<T>(this string dateTime, string? dateForma
             }
         }
 
-        if (!dateTime.ValidateDateTime(dateFormat))
+        if (dateTime.ValidateDateTime(dateFormat))
         {
-            return false;
+            property.SetValue(target, DateTime.ParseExact(dateTime, dateFormat!, CultureInfo.CurrentCulture));
+
+            return true;
+        }
+
+        if (property.PropertyType.IsGenericType &&
+            property.PropertyType.GetGenericTypeDefinition() == typeof(DateTime?) &&
+            string.IsNullOrWhiteSpace(dateTime))
+        {
+            property.SetValue(target, null);
+            return true;
         }
 
-        property.SetValue(target, DateTime.ParseExact(dateTime, dateFormat!, CultureInfo.CurrentCulture));
+        property.SetValue(target, DateTime.MinValue);
         return true;
+
     }
 
-    public static bool ValidateDateTime(this string dateTime, string? dateFormat)
+    private static bool ValidateDateTime(this string dateTime, string? dateFormat)
     {
         return string.IsNullOrEmpty(dateFormat)
             ? DateTime.TryParse(dateTime, out _)