public async Task Should_not_add_error_if_value_is_within_character_range(int? min, int? max)
        {
            var sut = new StringTextValidator(minCharacters: min, maxCharacters: max);

            await sut.ValidateAsync(CreateString(1500), errors);

            Assert.Empty(errors);
        }
        public async Task Should_not_add_error_if_value_is_within_word_range(int? min, int? max, int length)
        {
            var sut = new StringTextValidator(minWords: min, maxWords: max);

            await sut.ValidateAsync(CreateSentence(length), errors);

            Assert.Empty(errors);
        }
        public async Task Should_not_add_error_if_value_is_empty()
        {
            var sut = new StringTextValidator(minCharacters: 5);

            await sut.ValidateAsync(string.Empty, errors);

            Assert.Empty(errors);
        }
        public async Task Should_add_error_if_value_is_greater_than_max_characters()
        {
            var sut = new StringTextValidator(maxCharacters: 1000);

            await sut.ValidateAsync(CreateString(1500), errors);

            errors.Should().BeEquivalentTo(
                new[] { "Must not have more than 1000 text character(s)." });
        }
        public async Task Should_add_error_if_value_is_smaller_than_min_characters()
        {
            var sut = new StringTextValidator(minCharacters: 2000);

            await sut.ValidateAsync(CreateString(1500), errors);

            errors.Should().BeEquivalentTo(
                new[] { "Must have at least 2000 text character(s)." });
        }
        public async Task Should_add_error_if_value_has_not_exact_number_of_characters()
        {
            var sut = new StringTextValidator(minCharacters: 5, maxCharacters: 5);

            await sut.ValidateAsync(CreateString(4), errors);

            errors.Should().BeEquivalentTo(
                new[] { "Must have exactly 5 text character(s)." });
        }
        public async Task Should_add_error_if_collection_count_is_not_in_word_range()
        {
            var sut = new StringTextValidator(minWords: 2000, maxWords: 5000);

            await sut.ValidateAsync(CreateSentence(1), errors);

            errors.Should().BeEquivalentTo(
                new[] { "Must have between 2000 and 5000 word(s)." });
        }
        public async Task Should_add_error_if_value_is_greater_than_max_words()
        {
            var sut = new StringTextValidator(maxWords: 1000);

            await sut.ValidateAsync(CreateSentence(1500), errors);

            errors.Should().BeEquivalentTo(
                new[] { "Must not have more than 1000 word(s)." });
        }
        public async Task Should_add_error_if_value_is_smaller_than_min_words()
        {
            var sut = new StringTextValidator(minWords: 2000);

            await sut.ValidateAsync(CreateSentence(1500), errors);

            errors.Should().BeEquivalentTo(
                new[] { "Must have at least 2000 word(s)." });
        }
        public async Task Should_add_error_if_value_has_not_exact_number_of_words()
        {
            var sut = new StringTextValidator(minWords: 5, maxWords: 5);

            await sut.ValidateAsync(CreateSentence(4), errors);

            errors.Should().BeEquivalentTo(
                new[] { "Must have exactly 5 word(s)." });
        }
        public async Task Should_add_error_if_collection_count_is_not_in_character_range()
        {
            var sut = new StringTextValidator(minCharacters: 2000, maxCharacters: 5000);

            await sut.ValidateAsync(CreateString(1), errors);

            errors.Should().BeEquivalentTo(
                new[] { "Must have between 2000 and 5000 text character(s)." });
        }