4276469310

Build Type

github

Committed by GitHub

Commit Message

Merge ef264419a into 33f23a935

Pull Request Pull Request #19: feature/validate-that-general-message

Run Details

320 of 352 branches covered (90.91%)

Branch coverage included in aggregate %.

964 of 1032 relevant lines covered (93.41%)

121.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.46

/src/CrossValidation/Validations/ValidationExtensions.cs

﻿using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Numerics;
using CrossValidation.Validators;
using CrossValidation.Validators.LengthValidators;

namespace CrossValidation.Validations;

public static class ValidationExtensions
{
    public static IValidation<TField> NotNull<TField>(
        this IValidation<TField?> validation)
        where TField : class
    {
        var validationToReturn = validation;

        if (validation is IValidValidation<TField?> validValidation)
        {
            validationToReturn =
                validValidation.SetValidator(new NotNullValidator<TField?>(validValidation.GetFieldValue()));
        }

        return validationToReturn.Transform(x => x!);
    }

    public static IValidation<TField> NotNull<TField>(
        this IValidation<TField?> validation)
        where TField : struct
    {
        var validationToReturn = validation;

        if (validation is IValidValidation<TField?> validValidation)
        {
            validationToReturn =
                validValidation.SetValidator(new NotNullValidator<TField?>(validValidation.GetFieldValue()));
        }

        return validationToReturn.Transform(x => x!.Value);
    }

    public static IValidation<TField?> WhenNotNull<TField, TReturnedField>(
        this IValidation<TField?> validation,
        Func<IValidation<TField>, IValidation<TReturnedField>> notNullValidation)
        where TField : struct
    {
        if (validation is not IValidValidation<TField?> validValidation)
        {
            return validation;
        }

        if (validValidation.GetFieldValue() is not null)
        {
            var validationReturned = notNullValidation(validation.Transform(x => x!.Value));

            if (validationReturned is IInvalidValidation<TReturnedField>)
            {
                return IInvalidValidation<TField?>.Create();
            }
        }

        return validation;
    }

    public static IValidation<TField?> WhenNotNull<TField, TReturnedField>(
        this IValidation<TField?> validation,
        Func<IValidation<TField>, IValidation<TReturnedField>> notNullValidation)
        where TField : class
    {
        if (validation is not IValidValidation<TField?> validValidation)
        {
            return validation;
        }

        if (validValidation.GetFieldValue() is not null)
        {
            var validationReturned = notNullValidation(validation.Transform(x => x!));

            if (validationReturned is IInvalidValidation<TReturnedField>)
            {
                return IInvalidValidation<TField?>.Create();
            }
        }

        return validation;
    }

    public static IValidation<TField?> Null<TField>(
        this IValidation<TField?> validation)
        where TField : class
    {
        if (validation is IValidValidation<TField?> validValidation)
        {
            return validation.SetValidator(new NullValidator<TField?>(validValidation.GetFieldValue()));
        }

        return validation;
    }

    public static IValidation<TField?> Null<TField>(
        this IValidation<TField?> validation)
        where TField : struct
    {
        if (validation is IValidValidation<TField?> validValidation)
        {
            return validation.SetValidator(new NullValidator<TField?>(validValidation.GetFieldValue()));
        }

        return validation;
    }

    public static IValidation<TField> GreaterThan<TField>(
        this IValidation<TField> validation,
        TField valueToCompare)
        where TField : IComparisonOperators<TField, TField, bool>
    {
        if (validation is IValidValidation<TField> validValidation)
        {
            return validation.SetValidator(new GreaterThanValidator<TField>(validValidation.GetFieldValue(),
                valueToCompare));
        }

        return validation;
    }

    public static IValidation<TField> Enum<TField>(
        this IValidation<TField> validation)
        where TField : Enum
    {
        if (validation is IValidValidation<TField> validValidation)
        {
            return validation.SetValidator(new EnumValidator<TField>(validValidation.GetFieldValue(), typeof(TField)));
        }

        return validation;
    }

    public static IValidation<TEnum> Enum<TEnum>(
        this IValidation<int> validation)
        where TEnum : Enum
    {
        var validationToReturn = validation;

        if (validation is IValidValidation<int> validValidation)
        {
            validationToReturn =
                validValidation.SetValidator(new EnumValidator<int>(validValidation.GetFieldValue(), typeof(TEnum)));
        }

        return validationToReturn.Transform(x => (TEnum)(object)x);
    }

    public static IValidation<TEnum> Enum<TEnum>(
        this IValidation<string> validation)
        where TEnum : Enum
    {
        var validationToReturn = validation;

        if (validation is IValidValidation<string> validValidation)
        {
            validationToReturn = validValidation.SetValidator(
                new EnumValidator<string>(validValidation.GetFieldValue(), typeof(TEnum)));
        }

        return validationToReturn.Transform(x =>
            (TEnum)System.Enum.Parse(typeof(TEnum), x, ignoreCase: true));
    }

    public static IValidation<TField> Enum<TField>(
        this IValidation<TField> validation,
        params TField[] allowedValues)
        where TField : Enum
    {
        if (validation is IValidValidation<TField> validValidation)
        {
            return validation.SetValidator(
                new EnumRangeValidator<TField, TField>(validValidation.GetFieldValue(), allowedValues));
        }

        return validation;
    }

    public static IValidation<TEnum> Enum<TEnum>(
        this IValidation<int> validation,
        params TEnum[] allowedValues)
        where TEnum : Enum
    {
        var validationToReturn = validation;

        if (validation is IValidValidation<int> validValidation)
        {
            validationToReturn = validValidation.SetValidator(
                new EnumRangeValidator<int, TEnum>(validValidation.GetFieldValue(), allowedValues));
        }

        return validationToReturn.Transform(x => (TEnum)(object)x);
    }

    public static IValidation<TEnum> Enum<TEnum>(
        this IValidation<string> validation,
        params TEnum[] allowedValues)
        where TEnum : Enum
    {
        var validationToReturn = validation;

        if (validation is IValidValidation<string> validValidation)
        {
            validationToReturn = validValidation.SetValidator(
                new EnumRangeValidator<string, TEnum>(validValidation.GetFieldValue(), allowedValues));
        }

        return validationToReturn.Transform(x =>
            (TEnum)System.Enum.Parse(typeof(TEnum), x, ignoreCase: true));
    }

    public static IValidation<string> LengthRange(
        this IValidation<string> validation,
        int minimum,
        int maximum)
    {
        if (validation is IValidValidation<string> validValidation)
        {
            return validation.SetValidator(new LengthRangeValidator(validValidation.GetFieldValue(), minimum, maximum));
        }

        return validation;
    }

    public static IValidation<string> MinimumLength(
        this IValidation<string> validation,
        int minimum)
    {
        if (validation is IValidValidation<string> validValidation)
        {
            return validation.SetValidator(new MinimumLengthValidator(validValidation.GetFieldValue(), minimum));
        }

        return validation;
    }

    public static IValidation<IEnumerable<TReturnedField>> ForEach<TInnerType, TReturnedField>(
        this IValidation<IEnumerable<TInnerType>> validation,
        Func<IValidation<TInnerType>, IValidation<TReturnedField>> action)
    {
        if (validation is not IValidValidation<IEnumerable<TInnerType>> validValidation)
        {
            return IInvalidValidation<IEnumerable<TReturnedField>>.Create();
        }

        var fieldCollection = validValidation.GetFieldValue();
        var fieldFullPath = validValidation.Context.FieldName;
        var index = 0;
        var areErrors = false;
        var returnedFieldValues = new List<TReturnedField>();

        foreach (var innerField in fieldCollection)
        {
            var newValidation = IValidValidation<TInnerType>.CreateFromField(
                innerField,
                validValidation.CrossErrorToException,
                generalizeError: validValidation.Context.GeneralizeError,
                fieldFullPath: fieldFullPath,
                context:validValidation.Context,
                index: index,
                parentPath: validValidation.Context.ParentPath,
                error: validValidation.Context.Error,
                message: validValidation.Context.Message,
                code: validValidation.Context.Code,
                details: validValidation.Context.Details,
                httpStatusCode: validValidation.Context.HttpStatusCode,
                fieldDisplayName: validValidation.Context.FieldDisplayName);
            var validationReturned = action(newValidation);

            if (validationReturned is IInvalidValidation<TReturnedField>)
            {
                if (validValidation.Context.ValidationMode is ValidationMode.StopValidationOnFirstError
                    || validValidation.Context.ValidationMode is ValidationMode.AccumulateFirstErrorEachValidation)
                {
                    return IInvalidValidation<IEnumerable<TReturnedField>>.Create();
                }
                else if (validValidation.Context.ValidationMode is ValidationMode
                             .AccumulateFirstErrorEachValidationAndAllFirstErrorsCollectionIteration)
                {
                    areErrors = true;
                    index++;
                    continue;
                }
                else
                {
                    throw new UnreachableException();
                }
            }
            else if (validationReturned is IValidValidation<TReturnedField> validValidationReturned)
            {
                returnedFieldValues.Add(validValidationReturned.GetFieldValue());
            }
            else
            {
                throw new UnreachableException();
            }

            index++;
        }

        if (areErrors)
        {
            return IInvalidValidation<IEnumerable<TReturnedField>>.Create();
        }
        else
        {
            return IValidValidation<IEnumerable<TReturnedField>>.CreateFromField(
                returnedFieldValues,
                validValidation.CrossErrorToException,
                fieldFullPath: fieldFullPath,
                context: validValidation.Context,
                index: index,
                parentPath: validValidation.Context.ParentPath);
        }
    }

    public static IValidation<string> Regex(
        this IValidation<string> validation,
        [StringSyntax(StringSyntaxAttribute.Regex)]
        string pattern)
    {
        if (validation is IValidValidation<string> validValidation)
        {
            return validation.SetValidator(
                new RegularExpressionValidator(validValidation.GetFieldValue(), pattern));
        }

        return validation;
    }
}

1	using System.Diagnostics;
2	using System.Diagnostics.CodeAnalysis;
3	using System.Numerics;
4	using CrossValidation.Validators;
5	using CrossValidation.Validators.LengthValidators;
6
7	namespace CrossValidation.Validations;
8
9	public static class ValidationExtensions
10	{
11	public static IValidation<TField> NotNull<TField>(
12	this IValidation<TField?> validation)
13	where TField : class
14	{
15	var validationToReturn = validation;	32✔
16
17	if (validation is IValidValidation<TField?> validValidation)	32✔
18	{
19	validationToReturn =	32✔
20	validValidation.SetValidator(new NotNullValidator<TField?>(validValidation.GetFieldValue()));	32✔
21	}
22
23	return validationToReturn.Transform(x => x!);	35✔
24	}
25
26	public static IValidation<TField> NotNull<TField>(
27	this IValidation<TField?> validation)
28	where TField : struct
29	{
30	var validationToReturn = validation;	18✔
31
32	if (validation is IValidValidation<TField?> validValidation)	18✔
33	{
34	validationToReturn =	18✔
35	validValidation.SetValidator(new NotNullValidator<TField?>(validValidation.GetFieldValue()));	18✔
36	}
37
38	return validationToReturn.Transform(x => x!.Value);	15✔
39	}
40
41	public static IValidation<TField?> WhenNotNull<TField, TReturnedField>(
42	this IValidation<TField?> validation,
43	Func<IValidation<TField>, IValidation<TReturnedField>> notNullValidation)
44	where TField : struct
45	{
46	if (validation is not IValidValidation<TField?> validValidation)	5!
47	{
48	return validation;	×
49	}
50
51	if (validValidation.GetFieldValue() is not null)	5✔
52	{
53	var validationReturned = notNullValidation(validation.Transform(x => x!.Value));	4✔
54
55	if (validationReturned is IInvalidValidation<TReturnedField>)	1✔
56	{
57	return IInvalidValidation<TField?>.Create();	1✔
58	}
59	}
60
61	return validation;	3✔
62	}
63
64	public static IValidation<TField?> WhenNotNull<TField, TReturnedField>(
65	this IValidation<TField?> validation,
66	Func<IValidation<TField>, IValidation<TReturnedField>> notNullValidation)
67	where TField : class
68	{
69	if (validation is not IValidValidation<TField?> validValidation)	4!
70	{
71	return validation;	×
72	}
73
74	if (validValidation.GetFieldValue() is not null)	4✔
75	{
76	var validationReturned = notNullValidation(validation.Transform(x => x!));	4✔
77
78	if (validationReturned is IInvalidValidation<TReturnedField>)	1✔
79	{
80	return IInvalidValidation<TField?>.Create();	1✔
81	}
82	}
83
84	return validation;	2✔
85	}
86
87	public static IValidation<TField?> Null<TField>(
88	this IValidation<TField?> validation)
89	where TField : class
90	{
91	if (validation is IValidValidation<TField?> validValidation)	8!
92	{
93	return validation.SetValidator(new NullValidator<TField?>(validValidation.GetFieldValue()));	8✔
94	}
95
96	return validation;	×
97	}
98
99	public static IValidation<TField?> Null<TField>(
100	this IValidation<TField?> validation)
101	where TField : struct
102	{
103	if (validation is IValidValidation<TField?> validValidation)	1!
104	{
105	return validation.SetValidator(new NullValidator<TField?>(validValidation.GetFieldValue()));	1✔
106	}
107
108	return validation;	×
109	}
110
111	public static IValidation<TField> GreaterThan<TField>(
112	this IValidation<TField> validation,
113	TField valueToCompare)
114	where TField : IComparisonOperators<TField, TField, bool>
115	{
116	if (validation is IValidValidation<TField> validValidation)	104✔
117	{
118	return validation.SetValidator(new GreaterThanValidator<TField>(validValidation.GetFieldValue(),	98✔
119	valueToCompare));	98✔
120	}
121
122	return validation;	6✔
123	}
124
125	public static IValidation<TField> Enum<TField>(
126	this IValidation<TField> validation)
127	where TField : Enum
128	{
129	if (validation is IValidValidation<TField> validValidation)	2!
130	{
131	return validation.SetValidator(new EnumValidator<TField>(validValidation.GetFieldValue(), typeof(TField)));	2✔
132	}
133
134	return validation;	×
135	}
136
137	public static IValidation<TEnum> Enum<TEnum>(
138	this IValidation<int> validation)
139	where TEnum : Enum
140	{
141	var validationToReturn = validation;	2✔
142
143	if (validation is IValidValidation<int> validValidation)	2✔
144	{
145	validationToReturn =	2✔
146	validValidation.SetValidator(new EnumValidator<int>(validValidation.GetFieldValue(), typeof(TEnum)));	2✔
147	}
148
149	return validationToReturn.Transform(x => (TEnum)(object)x);	2✔
150	}
151
152	public static IValidation<TEnum> Enum<TEnum>(
153	this IValidation<string> validation)
154	where TEnum : Enum
155	{
156	var validationToReturn = validation;	3✔
157
158	if (validation is IValidValidation<string> validValidation)	3✔
159	{
160	validationToReturn = validValidation.SetValidator(	3✔
161	new EnumValidator<string>(validValidation.GetFieldValue(), typeof(TEnum)));	3✔
162	}
163
164	return validationToReturn.Transform(x =>	2✔
165	(TEnum)System.Enum.Parse(typeof(TEnum), x, ignoreCase: true));	4✔
166	}
167
168	public static IValidation<TField> Enum<TField>(
169	this IValidation<TField> validation,
170	params TField[] allowedValues)
171	where TField : Enum
172	{
173	if (validation is IValidValidation<TField> validValidation)	3!
174	{
175	return validation.SetValidator(	3✔
176	new EnumRangeValidator<TField, TField>(validValidation.GetFieldValue(), allowedValues));	3✔
177	}
178
179	return validation;	×
180	}
181
182	public static IValidation<TEnum> Enum<TEnum>(
183	this IValidation<int> validation,
184	params TEnum[] allowedValues)
185	where TEnum : Enum
186	{
187	var validationToReturn = validation;	2✔
188
189	if (validation is IValidValidation<int> validValidation)	2✔
190	{
191	validationToReturn = validValidation.SetValidator(	2✔
192	new EnumRangeValidator<int, TEnum>(validValidation.GetFieldValue(), allowedValues));	2✔
193	}
194
195	return validationToReturn.Transform(x => (TEnum)(object)x);	2✔
196	}
197
198	public static IValidation<TEnum> Enum<TEnum>(
199	this IValidation<string> validation,
200	params TEnum[] allowedValues)
201	where TEnum : Enum
202	{
203	var validationToReturn = validation;	2✔
204
205	if (validation is IValidValidation<string> validValidation)	2✔
206	{
207	validationToReturn = validValidation.SetValidator(	2✔
208	new EnumRangeValidator<string, TEnum>(validValidation.GetFieldValue(), allowedValues));	2✔
209	}
210
211	return validationToReturn.Transform(x =>	1✔
212	(TEnum)System.Enum.Parse(typeof(TEnum), x, ignoreCase: true));	2✔
213	}
214
215	public static IValidation<string> LengthRange(
216	this IValidation<string> validation,
217	int minimum,
218	int maximum)
219	{
220	if (validation is IValidValidation<string> validValidation)	3✔
221	{
222	return validation.SetValidator(new LengthRangeValidator(validValidation.GetFieldValue(), minimum, maximum));	2✔
223	}
224
225	return validation;	1✔
226	}
227
228	public static IValidation<string> MinimumLength(
229	this IValidation<string> validation,
230	int minimum)
231	{
232	if (validation is IValidValidation<string> validValidation)	1!
233	{
234	return validation.SetValidator(new MinimumLengthValidator(validValidation.GetFieldValue(), minimum));	1✔
235	}
236
237	return validation;	×
238	}
239
240	public static IValidation<IEnumerable<TReturnedField>> ForEach<TInnerType, TReturnedField>(
241	this IValidation<IEnumerable<TInnerType>> validation,
242	Func<IValidation<TInnerType>, IValidation<TReturnedField>> action)
243	{
244	if (validation is not IValidValidation<IEnumerable<TInnerType>> validValidation)	25!
245	{
246	return IInvalidValidation<IEnumerable<TReturnedField>>.Create();	×
247	}
248
249	var fieldCollection = validValidation.GetFieldValue();	25✔
250	var fieldFullPath = validValidation.Context.FieldName;	25✔
251	var index = 0;	25✔
252	var areErrors = false;	25✔
253	var returnedFieldValues = new List<TReturnedField>();	25✔
254
255	foreach (var innerField in fieldCollection)	139✔
256	{
257	var newValidation = IValidValidation<TInnerType>.CreateFromField(	53✔
258	innerField,	53✔
259	validValidation.CrossErrorToException,	53✔
260	generalizeError: validValidation.Context.GeneralizeError,	53✔
261	fieldFullPath: fieldFullPath,	53✔
262	context:validValidation.Context,	53✔
263	index: index,	53✔
264	parentPath: validValidation.Context.ParentPath,	53✔
265	error: validValidation.Context.Error,	53✔
266	message: validValidation.Context.Message,	53✔
267	code: validValidation.Context.Code,	53✔
268	details: validValidation.Context.Details,	53✔
269	httpStatusCode: validValidation.Context.HttpStatusCode,	53✔
270	fieldDisplayName: validValidation.Context.FieldDisplayName);	53✔
271	var validationReturned = action(newValidation);	53✔
272
273	if (validationReturned is IInvalidValidation<TReturnedField>)	43✔
274	{
275	if (validValidation.Context.ValidationMode is ValidationMode.StopValidationOnFirstError	14✔
276	\|\| validValidation.Context.ValidationMode is ValidationMode.AccumulateFirstErrorEachValidation)	14✔
277	{
278	return IInvalidValidation<IEnumerable<TReturnedField>>.Create();	7✔
279	}
280	else if (validValidation.Context.ValidationMode is ValidationMode	7!
281	.AccumulateFirstErrorEachValidationAndAllFirstErrorsCollectionIteration)	7✔
282	{
283	areErrors = true;	7✔
284	index++;	7✔
285	continue;	7✔
286	}
287	else
288	{
289	throw new UnreachableException();	×
290	}
291	}
292	else if (validationReturned is IValidValidation<TReturnedField> validValidationReturned)	29!
293	{
294	returnedFieldValues.Add(validValidationReturned.GetFieldValue());	29✔
295	}
296	else
297	{
298	throw new UnreachableException();	×
299	}
300
301	index++;	29✔
302	}
303
304	if (areErrors)	8✔
305	{
306	return IInvalidValidation<IEnumerable<TReturnedField>>.Create();	6✔
307	}
308	else
309	{
310	return IValidValidation<IEnumerable<TReturnedField>>.CreateFromField(	2✔
311	returnedFieldValues,	2✔
312	validValidation.CrossErrorToException,	2✔
313	fieldFullPath: fieldFullPath,	2✔
314	context: validValidation.Context,	2✔
315	index: index,	2✔
316	parentPath: validValidation.Context.ParentPath);	2✔
317	}
318	}	7✔
319
320	public static IValidation<string> Regex(
321	this IValidation<string> validation,
322	[StringSyntax(StringSyntaxAttribute.Regex)]
323	string pattern)
324	{
325	if (validation is IValidValidation<string> validValidation)	×
326	{
327	return validation.SetValidator(	×
328	new RegularExpressionValidator(validValidation.GetFieldValue(), pattern));	×
329	}
330
331	return validation;	×
332	}
333	}

AndreuCodina / CrossValidation / 4276469310

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous