4282269105

Build Type

github

Committed by GitHub

Commit Message

Merge c29637dac into 33f23a935

Pull Request Pull Request #19: General errors by default with That()

Run Details

328 of 360 branches covered (91.11%)

Branch coverage included in aggregate %.

55 of 55 new or added lines in 5 files covered. (100.0%)

970 of 1038 relevant lines covered (93.45%)

128.32 hits per line

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

96.58

/src/CrossValidation/Validations/ValidValidation.cs

﻿using System.Diagnostics;
using System.Net;
using CrossValidation.Errors;
using CrossValidation.Exceptions;
using CrossValidation.Resources;

namespace CrossValidation.Validations;

public interface IValidValidation<out TField> : IValidation<TField>
{
    public string? Code { get; set; }
    public string? Message { get; set; }
    public string? Details { get; set; }
    public ICrossError? Error { get; set; }
    public string? FieldDisplayName { get; set; }
    public HttpStatusCode? HttpStatusCode { get; set; }
    bool ExecuteNextValidator { get; set; }
    public TField GetFieldValue();
    public ValidationContext Context { get; set; }
    public string? FieldFullPath { get; set; }
    public Type CrossErrorToException { get; set; }
    void HandleError(ICrossError error);
    void TakeCustomizationsFromError(ICrossError error);

    public static IValidation<TField> CreateFromField(
        TField fieldValue,
        Type crossErrorToException,
        bool generalizeError = true,
        string? fieldFullPath = null,
        ValidationContext? context = null,
        int? index = null,
        string? parentPath = null,
        ICrossError? error = null,
        string? message = null,
        string? code = null,
        string? details = null,
        HttpStatusCode? httpStatusCode = null,
        string? fieldDisplayName = null)
    {
        return new ValidValidation<TField>(
            fieldValue: fieldValue,
            crossErrorToException: crossErrorToException,
            generalizeError: generalizeError,
            fieldFullPath: fieldFullPath,
            context: context,
            index: index,
            parentPath: parentPath,
            error: error,
            message: message,
            code: code,
            details: details,
            httpStatusCode: httpStatusCode,
            fieldDisplayName: fieldDisplayName);
    }

    public static IValidation<TField> CreateFromFieldName(
        TField fieldValue,
        Type crossErrorToException,
        string fieldName,
        bool allowFieldNameWithoutModel,
        ValidationContext? context = null,
        ICrossError? error = null,
        string? message = null,
        string? code = null,
        string? details = null,
        HttpStatusCode? httpStatusCode = null,
        string? fieldDisplayName = null)
    {
        if (!allowFieldNameWithoutModel)
        {
            if (!fieldName.Contains("."))
            {
                throw new ArgumentException("Use Field without a model is not allowed");
            }
        }

        var fieldFullPath = allowFieldNameWithoutModel
            ? fieldName
            : fieldName.Substring(fieldName.IndexOf('.') + 1);
        return new ValidValidation<TField>(
            fieldValue: fieldValue,
            crossErrorToException: crossErrorToException,
            generalizeError: false,
            fieldFullPath: fieldFullPath,
            context: context,
            error: error,
            message: message,
            code: code,
            details: details,
            httpStatusCode: httpStatusCode,
            fieldDisplayName: fieldDisplayName);
    }

    void Clean();
}

file class ValidValidation<TField> :
    Validation<TField>,
    IValidValidation<TField>
{
    private string? _code;
    private string? _message;
    private string? _details;
    private ICrossError? _error;
    private string? _fieldDisplayName;
    private HttpStatusCode? _httpStatusCode;

    public TField FieldValue { get; set; }
    public ValidationContext Context { get; set; }
    public string? FieldFullPath { get; set; }
    public Type CrossErrorToException { get; set; }

    public string? Code
    {
        get
        {
            if (Context.Code is not null)
            {
                return Context.Code;
            }

            return _code;
        }
        set
        {
            if (Context.Code is not null)
            {
                return;
            }

            _code = value;
        }
    }

    public string? Message
    {
        get
        {
            if (Context.Message is not null)
            {
                return Context.Message;
            }

            return _message;
        }
        set
        {
            if (Context.Message is not null)
            {
                return;
            }

            _message = value;
        }
    }

    public string? Details
    {
        get
        {
            if (Context.Details is not null)
            {
                return Context.Details;
            }

            return _details;
        }
        set
        {
            if (Context.Details is not null)
            {
                return;
            }

            _details = value;
        }
    }

    public ICrossError? Error
    {
        get
        {
            if (Context.Error is not null)
            {
                return Context.Error;
            }

            return _error;
        }
        set
        {
            if (Context.Error is not null)
            {
                return;
            }

            _error = value;
        }
    }

    public string? FieldDisplayName
    {
        get
        {
            if (Context.FieldDisplayName is not null)
            {
                return Context.FieldDisplayName;
            }

            return _fieldDisplayName;
        }
        set
        {
            if (Context.FieldDisplayName is not null)
            {
                return;
            }

            _fieldDisplayName = value;
        }
    }

    public HttpStatusCode? HttpStatusCode
    {
        get
        {
            if (Context.HttpStatusCode is not null)
            {
                return Context.HttpStatusCode;
            }

            return _httpStatusCode;
        }
        set
        {
            if (Context.HttpStatusCode is not null)
            {
                return;
            }

            _httpStatusCode = value;
        }
    }

    public bool ExecuteNextValidator { get; set; } = true;

    public ValidValidation(
        TField fieldValue,
        Type crossErrorToException,
        bool generalizeError,
        string? fieldFullPath = null,
        ValidationContext? context = null,
        int? index = null,
        string? parentPath = null,
        ICrossError? error = null,
        string? message = null,
        string? code = null,
        string? details = null,
        HttpStatusCode? httpStatusCode = null,
        string? fieldDisplayName = null)
    {
        FieldValue = fieldValue;
        CrossErrorToException = crossErrorToException;
        Context = context ?? new ValidationContext();
        FieldDisplayName = null;
        FieldFullPath = fieldFullPath;
        Context.GeneralizeError = Context.IsChildContext && Context.GeneralizeError
            ? true
            : generalizeError;;

        var indexRepresentation = Context.FieldName is not null && index is not null
            ? $"[{index}]"
            : null;
        string? parentPathValue = null;

        if (parentPath is not null)
        {
            parentPathValue = parentPath;
        }
        else if (Context.ParentPath is not null)
        {
            parentPathValue = Context.ParentPath;
        }

        if (parentPathValue is not null)
        {
            parentPathValue += ".";
        }

        Context.FieldName = parentPathValue + fieldFullPath + indexRepresentation;

        if (Context.FieldName is "")
        {
            Context.FieldName = null;
        }

        Context.Error = error;
        Context.Message = message;
        Context.Code = code;
        Context.Details = details;
        Context.HttpStatusCode = httpStatusCode;
        Context.FieldDisplayName = fieldDisplayName;
    }

    public TField GetFieldValue()
    {
        return FieldValue;
    }

    public void TakeCustomizationsFromError(ICrossError error)
    {
        Code = error.Code ?? Code;
        Message = error.Message ?? Message;
        Details = error.Details ?? Details;
        HttpStatusCode = error.HttpStatusCode ?? HttpStatusCode;
        FieldDisplayName = error.FieldDisplayName ?? FieldDisplayName;
    }

    public void HandleError(ICrossError error)
    {
        var errorToAdd = Error ?? error;
        AddError(errorToAdd);

        if (Context is {ValidationMode: ValidationMode.StopValidationOnFirstError})
        {
            if (Context.ErrorsCollected!.Count == 1)
            {
                throw Context.ErrorsCollected[0].ToException();
            }
        }
    }

    public override TField Instance()
    {
        return FieldValue;
    }

    public override TInstance Instance<TInstance>(Func<TField, TInstance> fieldToInstance)
    {
        try
        {
            return fieldToInstance(FieldValue);
        }
        catch (CrossException e)
        {
            e.Error.FieldName = null;
            e.Error.FieldValue = null;
            e.Error.PlaceholderValues = null;
            e.Error.CrossErrorToException = CrossErrorToException;
            TakeCustomizationsFromInstanceError(e.Error);
            HandleError(e.Error);
            throw new UnreachableException();
        }
    }

    public void Clean()
    {
        Code = null;
        Message = null;
        Details = null;
        Error = null;
        HttpStatusCode = null;
        FieldDisplayName = null;
        ExecuteNextValidator = true;
    }

    private void AddError(ICrossError error)
    {
        AddCustomizationsToError(error);
        Context.ErrorsCollected ??= new List<ICrossError>();
        error.AddPlaceholderValues();
        Context.ErrorsCollected.Add(error);
    }

    private void AddCustomizationsToError(ICrossError error)
    {
        error.FieldName = Context.FieldName;
        error.FieldDisplayName = GetFieldDisplayNameToFill(error);
        error.FieldValue = FieldValue;
        error.Code = GetCodeToFill(error);
        error.Message = GetMessageToFill(error);
        error.Details = Details ?? error.Details;
        error.HttpStatusCode = HttpStatusCode ?? error.HttpStatusCode;
    }

    private string? GetCodeToFill(ICrossError error)
    {
        if (Code is not null)
        {
            return Code;
        }
        
        if (Context.GeneralizeError)
        {
            return nameof(ErrorResource.General);
        }

        return error.Code;
    }

    private string? GetMessageToFill(ICrossError error)
    {
        if (Message is not null)
        {
            return Message;
        }

        if (Code is not null)
        {
            return CrossValidationOptions.GetMessageFromCode(Code);
        }
        
        if (Context.GeneralizeError)
        {
            return CrossValidationOptions.GetMessageFromCode(nameof(ErrorResource.General));
        }

        if (error.Message is not null)
        {
            return error.Message;
        }

        if (error.Code is not null)
        {
            return CrossValidationOptions.GetMessageFromCode(error.Code);
        }

        return null;
    }

    private string? GetFieldDisplayNameToFill(ICrossError error)
    {
        if (FieldDisplayName is not null)
        {
            return FieldDisplayName;
        }

        if (error.FieldDisplayName is not null)
        {
            return error.FieldDisplayName;
        }

        if (error.FieldName is not null)
        {
            return error.FieldName;
        }

        return null;
    }
    
    private void TakeCustomizationsFromInstanceError(ICrossError error)
    {
        if (!Context.GeneralizeError)
        {
            return;
        }
        
        Code ??= error.Code;
        Message ??= error.Message;
    }
}

1	using System.Diagnostics;
2	using System.Net;
3	using CrossValidation.Errors;
4	using CrossValidation.Exceptions;
5	using CrossValidation.Resources;
6
7	namespace CrossValidation.Validations;
8
9	public interface IValidValidation<out TField> : IValidation<TField>
10	{
11	public string? Code { get; set; }
12	public string? Message { get; set; }
13	public string? Details { get; set; }
14	public ICrossError? Error { get; set; }
15	public string? FieldDisplayName { get; set; }
16	public HttpStatusCode? HttpStatusCode { get; set; }
17	bool ExecuteNextValidator { get; set; }
18	public TField GetFieldValue();
19	public ValidationContext Context { get; set; }
20	public string? FieldFullPath { get; set; }
21	public Type CrossErrorToException { get; set; }
22	void HandleError(ICrossError error);
23	void TakeCustomizationsFromError(ICrossError error);
24
25	public static IValidation<TField> CreateFromField(
26	TField fieldValue,
27	Type crossErrorToException,
28	bool generalizeError = true,
29	string? fieldFullPath = null,
30	ValidationContext? context = null,
31	int? index = null,
32	string? parentPath = null,
33	ICrossError? error = null,
34	string? message = null,
35	string? code = null,
36	string? details = null,
37	HttpStatusCode? httpStatusCode = null,
38	string? fieldDisplayName = null)
39	{
40	return new ValidValidation<TField>(	189✔
41	fieldValue: fieldValue,	189✔
42	crossErrorToException: crossErrorToException,	189✔
43	generalizeError: generalizeError,	189✔
44	fieldFullPath: fieldFullPath,	189✔
45	context: context,	189✔
46	index: index,	189✔
47	parentPath: parentPath,	189✔
48	error: error,	189✔
49	message: message,	189✔
50	code: code,	189✔
51	details: details,	189✔
52	httpStatusCode: httpStatusCode,	189✔
53	fieldDisplayName: fieldDisplayName);	189✔
54	}
55
56	public static IValidation<TField> CreateFromFieldName(
57	TField fieldValue,
58	Type crossErrorToException,
59	string fieldName,
60	bool allowFieldNameWithoutModel,
61	ValidationContext? context = null,
62	ICrossError? error = null,
63	string? message = null,
64	string? code = null,
65	string? details = null,
66	HttpStatusCode? httpStatusCode = null,
67	string? fieldDisplayName = null)
68	{
69	if (!allowFieldNameWithoutModel)	87✔
70	{
71	if (!fieldName.Contains("."))	85✔
72	{
73	throw new ArgumentException("Use Field without a model is not allowed");	1✔
74	}
75	}
76
77	var fieldFullPath = allowFieldNameWithoutModel	86✔
78	? fieldName	86✔
79	: fieldName.Substring(fieldName.IndexOf('.') + 1);	86✔
80	return new ValidValidation<TField>(	86✔
81	fieldValue: fieldValue,	86✔
82	crossErrorToException: crossErrorToException,	86✔
83	generalizeError: false,	86✔
84	fieldFullPath: fieldFullPath,	86✔
85	context: context,	86✔
86	error: error,	86✔
87	message: message,	86✔
88	code: code,	86✔
89	details: details,	86✔
90	httpStatusCode: httpStatusCode,	86✔
91	fieldDisplayName: fieldDisplayName);	86✔
92	}
93
94	void Clean();
95	}
96
97	file class ValidValidation<TField> :
98	Validation<TField>,
99	IValidValidation<TField>
100	{
101	private string? _code;
102	private string? _message;
103	private string? _details;
104	private ICrossError? _error;
105	private string? _fieldDisplayName;
106	private HttpStatusCode? _httpStatusCode;
107
108	public TField FieldValue { get; set; }	780✔
109	public ValidationContext Context { get; set; }	8,495✔
110	public string? FieldFullPath { get; set; }	283✔
111	public Type CrossErrorToException { get; set; }	550✔
112
113	public string? Code
114	{
115	get
116	{
117	if (Context.Code is not null)	394✔
118	{
119	return Context.Code;	10✔
120	}
121
122	return _code;	384✔
123	}
124	set
125	{
126	if (Context.Code is not null)	246✔
127	{
128	return;	6✔
129	}
130
131	_code = value;	240✔
132	}	240✔
133	}
134
135	public string? Message
136	{
137	get
138	{
139	if (Context.Message is not null)	258✔
140	{
141	return Context.Message;	10✔
142	}
143
144	return _message;	248✔
145	}
146	set
147	{
148	if (Context.Message is not null)	228✔
149	{
150	return;	6✔
151	}
152
153	_message = value;	222✔
154	}	222✔
155	}
156
157	public string? Details
158	{
159	get
160	{
161	if (Context.Details is not null)	218✔
162	{
163	return Context.Details;	7✔
164	}
165
166	return _details;	211✔
167	}
168	set
169	{
170	if (Context.Details is not null)	216✔
171	{
172	return;	6✔
173	}
174
175	_details = value;	210✔
176	}	210✔
177	}
178
179	public ICrossError? Error
180	{
181	get
182	{
183	if (Context.Error is not null)	183✔
184	{
185	return Context.Error;	4✔
186	}
187
188	return _error;	179✔
189	}
190	set
191	{
192	if (Context.Error is not null)	181✔
193	{
194	return;	3✔
195	}
196
197	_error = value;	178✔
198	}	178✔
199	}
200
201	public string? FieldDisplayName
202	{
203	get
204	{
205	if (Context.FieldDisplayName is not null)	237✔
206	{
207	return Context.FieldDisplayName;	10✔
208	}
209
210	return _fieldDisplayName;	227✔
211	}
212	set
213	{
214	if (Context.FieldDisplayName is not null)	495✔
215	{
216	return;	8✔
217	}
218
219	_fieldDisplayName = value;	487✔
220	}	487✔
221	}
222
223	public HttpStatusCode? HttpStatusCode
224	{
225	get
226	{
227	if (Context.HttpStatusCode is not null)	219✔
228	{
229	return Context.HttpStatusCode;	7✔
230	}
231
232	return _httpStatusCode;	212✔
233	}
234	set
235	{
236	if (Context.HttpStatusCode is not null)	213✔
237	{
238	return;	6✔
239	}
240
241	_httpStatusCode = value;	207✔
242	}	207✔
243	}
244
245	public bool ExecuteNextValidator { get; set; } = true;	954✔
246
247	public ValidValidation(	275✔
248	TField fieldValue,	275✔
249	Type crossErrorToException,	275✔
250	bool generalizeError,	275✔
251	string? fieldFullPath = null,	275✔
252	ValidationContext? context = null,	275✔
253	int? index = null,	275✔
254	string? parentPath = null,	275✔
255	ICrossError? error = null,	275✔
256	string? message = null,	275✔
257	string? code = null,	275✔
258	string? details = null,	275✔
259	HttpStatusCode? httpStatusCode = null,	275✔
260	string? fieldDisplayName = null)	275✔
261	{
262	FieldValue = fieldValue;	275✔
263	CrossErrorToException = crossErrorToException;	275✔
264	Context = context ?? new ValidationContext();	275✔
265	FieldDisplayName = null;	275✔
266	FieldFullPath = fieldFullPath;	275✔
267	Context.GeneralizeError = Context.IsChildContext && Context.GeneralizeError	275✔
268	? true	275✔
269	: generalizeError;;	275✔
270
271	var indexRepresentation = Context.FieldName is not null && index is not null	275✔
272	? $"[{index}]"	275✔
273	: null;	275✔
274	string? parentPathValue = null;	275✔
275
276	if (parentPath is not null)	275!
277	{
278	parentPathValue = parentPath;	×
279	}
280	else if (Context.ParentPath is not null)	275✔
281	{
282	parentPathValue = Context.ParentPath;	8✔
283	}
284
285	if (parentPathValue is not null)	275✔
286	{
287	parentPathValue += ".";	8✔
288	}
289
290	Context.FieldName = parentPathValue + fieldFullPath + indexRepresentation;	275✔
291
292	if (Context.FieldName is "")	275✔
293	{
294	Context.FieldName = null;	125✔
295	}
296
297	Context.Error = error;	275✔
298	Context.Message = message;	275✔
299	Context.Code = code;	275✔
300	Context.Details = details;	275✔
301	Context.HttpStatusCode = httpStatusCode;	275✔
302	Context.FieldDisplayName = fieldDisplayName;	275✔
303	}	275✔
304
305	public TField GetFieldValue()
306	{
307	return FieldValue;	349✔
308	}
309
310	public void TakeCustomizationsFromError(ICrossError error)
311	{
312	Code = error.Code ?? Code;	37✔
313	Message = error.Message ?? Message;	37✔
314	Details = error.Details ?? Details;	37✔
315	HttpStatusCode = error.HttpStatusCode ?? HttpStatusCode;	37✔
316	FieldDisplayName = error.FieldDisplayName ?? FieldDisplayName;	37✔
317	}	37✔
318
319	public void HandleError(ICrossError error)
320	{
321	var errorToAdd = Error ?? error;	139✔
322	AddError(errorToAdd);	139✔
323
324	if (Context is {ValidationMode: ValidationMode.StopValidationOnFirstError})	139✔
325	{
326	if (Context.ErrorsCollected!.Count == 1)	104✔
327	{
328	throw Context.ErrorsCollected[0].ToException();	104✔
329	}
330	}
331	}	35✔
332
333	public override TField Instance()
334	{
335	return FieldValue;	6✔
336	}
337
338	public override TInstance Instance<TInstance>(Func<TField, TInstance> fieldToInstance)
339	{
340	try
341	{
342	return fieldToInstance(FieldValue);	11✔
343	}
344	catch (CrossException e)	11✔
345	{
346	e.Error.FieldName = null;	11✔
347	e.Error.FieldValue = null;	11✔
348	e.Error.PlaceholderValues = null;	11✔
349	e.Error.CrossErrorToException = CrossErrorToException;	11✔
350	TakeCustomizationsFromInstanceError(e.Error);	11✔
351	HandleError(e.Error);	11✔
352	throw new UnreachableException();	×
353	}
354	}	×
355
356	public void Clean()
357	{
358	Code = null;	144✔
359	Message = null;	144✔
360	Details = null;	144✔
361	Error = null;	144✔
362	HttpStatusCode = null;	144✔
363	FieldDisplayName = null;	144✔
364	ExecuteNextValidator = true;	144✔
365	}	144✔
366
367	private void AddError(ICrossError error)
368	{
369	AddCustomizationsToError(error);	139✔
370	Context.ErrorsCollected ??= new List<ICrossError>();	139✔
371	error.AddPlaceholderValues();	139✔
372	Context.ErrorsCollected.Add(error);	139✔
373	}	139✔
374
375	private void AddCustomizationsToError(ICrossError error)
376	{
377	error.FieldName = Context.FieldName;	139✔
378	error.FieldDisplayName = GetFieldDisplayNameToFill(error);	139✔
379	error.FieldValue = FieldValue;	139✔
380	error.Code = GetCodeToFill(error);	139✔
381	error.Message = GetMessageToFill(error);	139✔
382	error.Details = Details ?? error.Details;	139✔
383	error.HttpStatusCode = HttpStatusCode ?? error.HttpStatusCode;	139✔
384	}	139✔
385
386	private string? GetCodeToFill(ICrossError error)
387	{
388	if (Code is not null)	139✔
389	{
390	return Code;	44✔
391	}
392
393	if (Context.GeneralizeError)	95✔
394	{
395	return nameof(ErrorResource.General);	40✔
396	}
397
398	return error.Code;	55✔
399	}
400
401	private string? GetMessageToFill(ICrossError error)
402	{
403	if (Message is not null)	139✔
404	{
405	return Message;	33✔
406	}
407
408	if (Code is not null)	106✔
409	{
410	return CrossValidationOptions.GetMessageFromCode(Code);	23✔
411	}
412
413	if (Context.GeneralizeError)	83✔
414	{
415	return CrossValidationOptions.GetMessageFromCode(nameof(ErrorResource.General));	35✔
416	}
417
418	if (error.Message is not null)	48!
419	{
420	return error.Message;	48✔
421	}
422
423	if (error.Code is not null)	×
424	{
425	return CrossValidationOptions.GetMessageFromCode(error.Code);	×
426	}
427
428	return null;	×
429	}
430
431	private string? GetFieldDisplayNameToFill(ICrossError error)
432	{
433	if (FieldDisplayName is not null)	139✔
434	{
435	return FieldDisplayName;	17✔
436	}
437
438	if (error.FieldDisplayName is not null)	122✔
439	{
440	return error.FieldDisplayName;	4✔
441	}
442
443	if (error.FieldName is not null)	118✔
444	{
445	return error.FieldName;	71✔
446	}
447
448	return null;	47✔
449	}
450
451	private void TakeCustomizationsFromInstanceError(ICrossError error)
452	{
453	if (!Context.GeneralizeError)	11✔
454	{
455	return;	3✔
456	}
457
458	Code ??= error.Code;	8✔
459	Message ??= error.Message;	8✔
460	}	8✔
461	}

AndreuCodina / CrossValidation / 4282269105

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