REFACTOR: Replace Dawn.Guard with Throw and refactor domain validatio…

…ns (#80)

## Description
Replace argument validation library Dawn.Guard with Throw library.
Refactor corresponding domain validations and use the occasion to
improve them.
Also refactor Handler and Validation classes to make them internal to
hide them from public exposure.

## Related Issue
Resolves #79 

## How Has This Been Tested?
Unit tests have been refactored and expanded to cover more cases than
before.

## Types of changes
<!--- What types of changes does your code introduce? Put an `x` in all
the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [X] Refactor
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)

## Checklist:
- [X] My code follows the code style of this project.
- [ ] My change requires a change to the documentation.
- [ ] I have updated the documentation accordingly.
- [X] I have read the **CONTRIBUTING** document.
- [X] I have added tests to cover my changes.
- [X] All new and existing tests passed.

src/Content/Backend/Solution/Monaco.Template.Backend.Application.Infrastructure/EntityConfigurations/CompanyEntityConfiguration.cs

@@ -13,15 +13,15 @@ public void Configure(EntityTypeBuilder<Company> builder)
 
 		builder.Property(x => x.Name)
 			   .IsRequired()
-			   .HasMaxLength(100);
+			   .HasMaxLength(Company.NameLength);
 
 		builder.Property(x => x.Email)
 			   .IsRequired()
-			   .HasMaxLength(255);
+			   .HasMaxLength(Company.EmailLength);
 
 		builder.Property(x => x.WebSiteUrl)
 			   .IsRequired(false)
-			   .HasMaxLength(300);
+			   .HasMaxLength(Company.WebSiteUrlLength);
 
 		builder.Property(x => x.Version)
 			   .IsRowVersion();
@@ -39,19 +39,19 @@ public void Configure(EntityTypeBuilder<Company> builder)
 						{
 							b.Property(x => x.Street)
 							 .IsRequired(false)
-							 .HasMaxLength(100);
+							 .HasMaxLength(Address.StreetLength);
 
 							b.Property(x => x.City)
 							 .IsRequired(false)
-							 .HasMaxLength(100);
+							 .HasMaxLength(Address.CityLength);
 
 							b.Property(x => x.County)
 							 .IsRequired(false)
-							 .HasMaxLength(100);
+							 .HasMaxLength(Address.CountyLength);
 
 							b.Property(x => x.PostCode)
 							 .IsRequired(false)
-							 .HasMaxLength(10);
+							 .HasMaxLength(Address.PostCodeLength);
 
 							b.HasOne(x => x.Country)
 							 .WithMany()

src/Content/Backend/Solution/Monaco.Template.Backend.Application.Infrastructure/EntityConfigurations/CountryEntityConfiguration.cs

@@ -15,7 +15,7 @@ public override void Configure(EntityTypeBuilder<Country> builder)
 
 		builder.Property(x => x.Name)
 			   .IsRequired()
-			   .HasMaxLength(100);
+			   .HasMaxLength(Country.NameLength);
 
 		if (CanRunSeed)
 			builder.HasData(CountrySeed.GetCountries());

src/Content/Backend/Solution/Monaco.Template.Backend.Application.Infrastructure/EntityConfigurations/FileEntityConfiguration.cs

@@ -20,15 +20,15 @@ public void Configure(EntityTypeBuilder<File> builder)
 
 		builder.Property(x => x.Name)
 			   .IsRequired()
-			   .HasMaxLength(300);
+			   .HasMaxLength(File.NameLength);
 
 		builder.Property(x => x.Extension)
 			   .IsRequired()
-			   .HasMaxLength(20);
+			   .HasMaxLength(File.ExtensionLength);
 
 		builder.Property(x => x.ContentType)
 			   .IsRequired()
-			   .HasMaxLength(50);
+			   .HasMaxLength(File.ContentTypeLength);
 
 		builder.Property(x => x.Size)
 			   .IsRequired();

src/Content/Backend/Solution/Monaco.Template.Backend.Application.Infrastructure/EntityConfigurations/ProductEntityConfiguration.cs

@@ -13,11 +13,11 @@ public void Configure(EntityTypeBuilder<Product> builder)
 
 		builder.Property(x => x.Title)
 			   .IsRequired()
-			   .HasMaxLength(100);
+			   .HasMaxLength(Product.TitleLength);
 
 		builder.Property(x => x.Description)
 			   .IsRequired()
-			   .HasMaxLength(500);
+			   .HasMaxLength(Product.DescriptionLength);
 
 		builder.Property(x => x.Price)
 			   .IsRequired()

src/Content/Backend/Solution/Monaco.Template.Backend.Application.Tests/Features/Company/CreateCompanyHandlerTests.cs

@@ -1,8 +1,9 @@
-using FluentAssertions;
+using AutoFixture;
+using FluentAssertions;
 using Monaco.Template.Backend.Application.Features.Company;
 using Monaco.Template.Backend.Application.Infrastructure.Context;
 using Monaco.Template.Backend.Common.Tests;
-using Monaco.Template.Backend.Common.Tests.Factories;
+using Monaco.Template.Backend.Domain.Tests.Factories;
 using Moq;
 using System.Diagnostics.CodeAnalysis;
 using Xunit;
@@ -14,18 +15,23 @@ namespace Monaco.Template.Backend.Application.Tests.Features.Company;
 public class CreateCompanyHandlerTests
 {
 	private readonly Mock<AppDbContext> _dbContextMock = new();
-	private static readonly CreateCompany.Command Command = new(It.IsAny<string>(), // Name
-																It.IsAny<string>(), // Email
-																It.IsAny<string>(), // WebsiteUrl
-																It.IsAny<string>(), // Street
-																It.IsAny<string>(), // City
-																It.IsAny<string>(), // County
-																It.IsAny<string>(), // PostCode
-																It.IsAny<Guid>()); // CountryId
+	private static readonly CreateCompany.Command Command;
 
+	static CreateCompanyHandlerTests()
+	{
+		var fixture = new Fixture();
+		Command = new(fixture.Create<string>(), // Name
+					  fixture.Create<string>(), // Email
+					  fixture.Create<string>(), // WebsiteUrl
+					  fixture.Create<string>(), // Street
+					  fixture.Create<string>(), // City
+					  fixture.Create<string>(), // County
+					  fixture.Create<string>(), // PostCode
+					  fixture.Create<Guid>()); // CountryId
+	}
 
 	[Theory(DisplayName = "Create new company succeeds")]
-	[AnonymousData]
+	[AutoDomainData]
 	public async Task CreateNewCompanySucceeds(Domain.Model.Country country)
 	{
 		_dbContextMock.CreateAndSetupDbSetMock(new List<Domain.Model.Company>(), out var companyDbSetMock)

src/Content/Backend/Solution/Monaco.Template.Backend.Application.Tests/Features/Company/CreateCompanyValidatorTests.cs

@@ -1,10 +1,12 @@
-using FluentAssertions;
+using AutoFixture;
+using FluentAssertions;
 using FluentValidation;
 using FluentValidation.TestHelper;
 using Monaco.Template.Backend.Application.Features.Company;
 using Monaco.Template.Backend.Application.Infrastructure.Context;
 using Monaco.Template.Backend.Common.Tests;
-using Monaco.Template.Backend.Common.Tests.Factories;
+using Monaco.Template.Backend.Domain.Model;
+using Monaco.Template.Backend.Domain.Tests.Factories;
 using Moq;
 using System.Diagnostics.CodeAnalysis;
 using Xunit;
@@ -16,14 +18,20 @@ namespace Monaco.Template.Backend.Application.Tests.Features.Company;
 public class CreateCompanyValidatorTests
 {
 	private readonly Mock<AppDbContext> _dbContextMock = new();
-	private static readonly CreateCompany.Command Command = new(It.IsAny<string>(),	// Name
-																It.IsAny<string>(),	// Email
-																It.IsAny<string>(),	// WebsiteUrl
-																It.IsAny<string>(),	// Street
-																It.IsAny<string>(),	// City
-																It.IsAny<string>(),	// County
-																It.IsAny<string>(),	// PostCode
-																It.IsAny<Guid>());	// CountryId
+	private static readonly CreateCompany.Command Command;
+
+	static CreateCompanyValidatorTests()
+	{
+		var fixture = new Fixture();
+		Command = new(fixture.Create<string>(), // Name
+					  fixture.Create<string>(), // Email
+					  fixture.Create<string>(), // WebsiteUrl
+					  fixture.Create<string>(), // Street
+					  fixture.Create<string>(), // City
+					  fixture.Create<string>(), // County
+					  fixture.Create<string>(), // PostCode
+					  fixture.Create<Guid>()); // CountryId
+	}
 
 	[Fact(DisplayName = "Validator's rule level cascade mode is 'Stop'")]
 	public void ValidatorRuleLevelCascadeModeIsStop()
@@ -34,14 +42,12 @@ public void ValidatorRuleLevelCascadeModeIsStop()
 	}
 
 	[Fact(DisplayName = "Name being valid does not generate validation error")]
-	public async Task NameDoesNotGenerateErrorWhenValid()
+	public async Task NameValidDoesNotGenerateError()
 	{
-		var command = Command with { Name = new string(It.IsAny<char>(), 100) };
-
 		_dbContextMock.CreateAndSetupDbSetMock(new List<Domain.Model.Company>());
 
 		var sut = new CreateCompany.Validator(_dbContextMock.Object);
-		var validationResult = await sut.TestValidateAsync(command, s => s.IncludeProperties(x => x.Name));
+		var validationResult = await sut.TestValidateAsync(Command, s => s.IncludeProperties(x => x.Name));
 
 		validationResult.ShouldNotHaveValidationErrorFor(x => x.Name);
 	}
@@ -63,20 +69,20 @@ public async Task NameIsEmptyGeneratesError()
 	[Fact(DisplayName = "Name with long value generates validation error")]
 	public async Task NameWithLongValueGeneratesError()
 	{
-		var command = Command with { Name = new string(It.IsAny<char>(), 101) };
+		var command = Command with { Name = new string(It.IsAny<char>(), Domain.Model.Company.NameLength + 1) };
 
 		var sut = new CreateCompany.Validator(_dbContextMock.Object);
 		var validationResult = await sut.TestValidateAsync(command, s => s.IncludeProperties(x => x.Name));
 
 		validationResult.ShouldHaveValidationErrorFor(x => x.Name)
 						.WithErrorCode("MaximumLengthValidator")
-						.WithMessageArgument("MaxLength", 100)
+						.WithMessageArgument("MaxLength", Domain.Model.Company.NameLength)
 						.Should()
 						.HaveCount(1);
 	}
 
 	[Theory(DisplayName = "Name which already exists generates validation error")]
-	[AnonymousData]
+	[AutoDomainData]
 	public async Task NameAlreadyExistsGeneratesError(Domain.Model.Company company)
 	{
 		var command = Command with { Name = company.Name };
@@ -120,7 +126,7 @@ public async Task EmailIsEmptyGeneratesError()
 	}
 
 	[Theory(DisplayName = "Email being invalid generates validation error")]
-	[AnonymousData]
+	[AutoDomainData]
 	public async Task EmailAddressIsInvalidGeneratesError(string email)
 	{
 		var command = Command with { Email = email };
@@ -134,17 +140,38 @@ public async Task EmailAddressIsInvalidGeneratesError(string email)
 						.HaveCount(1);
 	}
 
+	[Theory(DisplayName = "Email with long value generates validation error")]
+	[AutoDomainData]
+	public async Task EmailWithLongValueGeneratesError(string emailDomain)
+	{
+		var command = Command with
+					  {
+						  Email = string.Join("@",
+											  new string(It.IsAny<char>(), Domain.Model.Company.EmailLength),
+											  emailDomain)
+					  };
+
+		var sut = new CreateCompany.Validator(_dbContextMock.Object);
+		var validationResult = await sut.TestValidateAsync(command, s => s.IncludeProperties(x => x.Email));
+
+		validationResult.ShouldHaveValidationErrorFor(x => x.Email)
+						.WithErrorCode("MaximumLengthValidator")
+						.WithMessageArgument("MaxLength", Domain.Model.Company.EmailLength)
+						.Should()
+						.HaveCount(1);
+	}
+
 	[Fact(DisplayName = "Website URL with long value generates validation error")]
 	public async Task WebsiteUrlWithLongValueGeneratesError()
 	{
-		var command = Command with { WebSiteUrl = new string(It.IsAny<char>(), 301) };
+		var command = Command with { WebSiteUrl = new string(It.IsAny<char>(), Domain.Model.Company.WebSiteUrlLength + 1) };
 
 		var sut = new CreateCompany.Validator(_dbContextMock.Object);
 		var validationResult = await sut.TestValidateAsync(command, s => s.IncludeProperties(x => x.WebSiteUrl));
 
 		validationResult.ShouldHaveValidationErrorFor(x => x.WebSiteUrl)
 						.WithErrorCode("MaximumLengthValidator")
-						.WithMessageArgument("MaxLength", 300)
+						.WithMessageArgument("MaxLength", Domain.Model.Company.WebSiteUrlLength)
 						.Should()
 						.HaveCount(1);
 	}
@@ -163,14 +190,14 @@ public async Task WebsiteUrlWithEmptyValueDoesNotGenerateError()
 	[Fact(DisplayName = "Street with long value generates validation error")]
 	public async Task StreetWithLongValueGeneratesError()
 	{
-		var command = Command with { Street = new string(It.IsAny<char>(), 101) };
+		var command = Command with { Street = new string(It.IsAny<char>(), Address.StreetLength + 1) };
 
 		var validator = new CreateCompany.Validator(_dbContextMock.Object);
 		var validationResult = await validator.TestValidateAsync(command, s => s.IncludeProperties(x => x.Street));
 
 		validationResult.ShouldHaveValidationErrorFor(x => x.Street)
 						.WithErrorCode("MaximumLengthValidator")
-						.WithMessageArgument("MaxLength", 100)
+						.WithMessageArgument("MaxLength", Address.StreetLength)
 						.Should()
 						.HaveCount(1);
 	}
@@ -189,14 +216,14 @@ public async Task StreetWithEmptyValueDoesNotGenerateError()
 	[Fact(DisplayName = "City with long value generates validation error")]
 	public async Task CityWithLongValueGeneratesError()
 	{
-		var command = Command with { City = new string(It.IsAny<char>(), 101) };
+		var command = Command with { City = new string(It.IsAny<char>(), Address.CityLength + 1) };
 
 		var sut = new CreateCompany.Validator(_dbContextMock.Object);
 		var validationResult = await sut.TestValidateAsync(command, s => s.IncludeProperties(x => x.City));
 
 		validationResult.ShouldHaveValidationErrorFor(x => x.City)
 						.WithErrorCode("MaximumLengthValidator")
-						.WithMessageArgument("MaxLength", 100)
+						.WithMessageArgument("MaxLength", Address.CityLength)
 						.Should()
 						.HaveCount(1);
 	}
@@ -215,14 +242,14 @@ public async Task CityWithEmptyValueDoesNotGenerateError()
 	[Fact(DisplayName = "County with long value generates validation error")]
 	public async Task CountyWithLongValueGeneratesError()
 	{
-		var command = Command with { County = new string(It.IsAny<char>(), 101) };
+		var command = Command with { County = new string(It.IsAny<char>(), Address.CountyLength + 1) };
 
 		var sut = new CreateCompany.Validator(_dbContextMock.Object);
 		var validationResult = await sut.TestValidateAsync(command, s => s.IncludeProperties(x => x.County));
 
 		validationResult.ShouldHaveValidationErrorFor(x => x.County)
 						.WithErrorCode("MaximumLengthValidator")
-						.WithMessageArgument("MaxLength", 100)
+						.WithMessageArgument("MaxLength", Address.CountyLength)
 						.Should()
 						.HaveCount(1);
 	}
@@ -241,14 +268,14 @@ public async Task CountyWithEmptyValueDoesNotGenerateError()
 	[Fact(DisplayName = "Postcode with long value generates validation error")]
 	public async Task PostcodeWithLongValueGeneratesError()
 	{
-		var command = Command with { PostCode = new string(It.IsAny<char>(), 11) };
+		var command = Command with { PostCode = new string(It.IsAny<char>(), Address.PostCodeLength + 1) };
 
 		var sut = new CreateCompany.Validator(_dbContextMock.Object);
 		var validationResult = await sut.TestValidateAsync(command, s => s.IncludeProperties(x => x.PostCode));
 
 		validationResult.ShouldHaveValidationErrorFor(x => x.PostCode)
 						.WithErrorCode("MaximumLengthValidator")
-						.WithMessageArgument("MaxLength", 10)
+						.WithMessageArgument("MaxLength", Address.PostCodeLength)
 						.Should()
 						.HaveCount(1);
 	}
@@ -265,7 +292,7 @@ public async Task PostcodeWithEmptyValueDoesNotGenerateError()
 	}
 
 	[Theory(DisplayName = "Country being valid does not generate validation error")]
-	[AnonymousData(true)]
+	[AutoDomainData(true)]
 	public async Task CountryIsValidDoesNotGenerateError(Domain.Model.Country country)
 	{
 		var command = Command with { CountryId = country.Id };
@@ -328,7 +355,7 @@ public async Task CountryWithNullValueGeneratesErrorWhenAddressFieldsPresent()
 	}
 
 	[Theory(DisplayName = "Country that doesn't exist generates validation error")]
-	[AnonymousData]
+	[AutoDomainData]
 	public async Task CountryMustExistValidation(Domain.Model.Country country)
 	{
 		var command = Command with { CountryId = Guid.NewGuid() };

src/Content/Backend/Solution/Monaco.Template.Backend.Application.Tests/Features/Company/DeleteCompanyHandlerTests.cs

@@ -8,12 +8,12 @@
 using Monaco.Template.Backend.Application.Services.Contracts;
 #endif
 using Monaco.Template.Backend.Common.Tests;
-using Monaco.Template.Backend.Common.Tests.Factories;
 #if (filesSupport)
 using Monaco.Template.Backend.Domain.Model;
 #endif
 using Moq;
 using System.Diagnostics.CodeAnalysis;
+using Monaco.Template.Backend.Domain.Tests.Factories;
 using Xunit;
 
 namespace Monaco.Template.Backend.Application.Tests.Features.Company;
@@ -23,13 +23,13 @@ namespace Monaco.Template.Backend.Application.Tests.Features.Company;
 public class DeleteCompanyHandlerTests
 {
 	private readonly Mock<AppDbContext> _dbContextMock = new();
-	private static readonly DeleteCompany.Command Command = new(It.IsAny<Guid>());
+	private static readonly DeleteCompany.Command Command = new(new Fixture().Create<Guid>());
 	#if (filesSupport)
 	private readonly Mock<IFileService> _fileServiceMock = new();
 	#endif
 
 	[Theory(DisplayName = "Delete company succeeds")]
-	[AnonymousData(true)]
+	[AutoDomainData(true)]
 	#if (filesSupport)
 	public async Task DeleteCompanySucceeds(IFixture fixture, Domain.Model.Product[] products)
 	#else