6245535001

Committed 20 Sep 2023 07:44AM UTC coverage: 57.013%. First build

Build # 6245535001

Build Type

push

github

Committed by

web-flow

Commit Message

8.1.0 Release (#1628)

* Bump Newtonsoft.Json from 13.0.1 to 13.0.2

Bumps [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json) from 13.0.1 to 13.0.2.
- [Release notes](https://github.com/JamesNK/Newtonsoft.Json/releases)
- [Commits](https://github.com/JamesNK/Newtonsoft.Json/compare/13.0.1...13.0.2)

---
updated-dependencies:
- dependency-name: Newtonsoft.Json
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

* Bump NLog from 5.0.5 to 5.1.0

Bumps [NLog](https://github.com/NLog/NLog) from 5.0.5 to 5.1.0.
- [Release notes](https://github.com/NLog/NLog/releases)
- [Changelog](https://github.com/NLog/NLog/blob/dev/CHANGELOG.md)
- [Commits](https://github.com/NLog/NLog/compare/v5.0.5...v5.1.0)

---
updated-dependencies:
- dependency-name: NLog
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Bump NLog from 5.0.5 to 5.1.0

* Fix -r flag - should have been --results-directory all along

* Bump Newtonsoft.Json from 13.0.1 to 13.0.2

* Bump YamlDotNet from 12.0.2 to 12.1.0

Bumps [YamlDotNet](https://github.com/aaubry/YamlDotNet) from 12.0.2 to 12.1.0.
- [Release notes](https://github.com/aaubry/YamlDotNet/releases)
- [Commits](https://github.com/aaubry/YamlDotNet/compare/v12.0.2...v12.1.0)

---
updated-dependencies:
- dependency-name: YamlDotNet
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Bump Moq from 4.18.2 to 4.18.3

Bumps [Moq](https://github.com/moq/moq4) from 4.18.2 to 4.18.3.
- [Release notes](https://github.com/moq/moq4/releases)
- [Changelog](https://github.com/moq/moq4/blob/main/CHANGELOG.md)
- [Commits](https://github.com/moq/moq4/compare/v4.18.2...v4.18.3)

---
updated-dependencies:
- dependency-name: Moq
... (continued)

Run Details

10732 of 20257 branches covered (0.0%)

Branch coverage included in aggregate %.

48141 of 48141 new or added lines in 1086 files covered. (100.0%)

30685 of 52388 relevant lines covered (58.57%)

7387.88 hits per line

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

77.33

/Rdmp.Core/QueryBuilding/SyntaxChecking/SyntaxChecker.cs

// Copyright (c) The University of Dundee 2018-2019
// This file is part of the Research Data Management Platform (RDMP).
// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.

using System.Data;
using System.Linq;
using System.Text.RegularExpressions;
using Rdmp.Core.Curation.Data;
using Rdmp.Core.ReusableLibraryCode.Checks;

namespace Rdmp.Core.QueryBuilding.SyntaxChecking;

/// <summary>
/// Base class for all Checkers which check the Sql Syntax of an object e.g. an IFilter's WhereSQL
/// </summary>
public abstract class SyntaxChecker : ICheckable
{
    private static readonly Regex BracketedNumber =
        new(@"\([0-9]*\)", RegexOptions.Compiled | RegexOptions.CultureInvariant);

    private static readonly Regex QuotedString = new("'[^']*'", RegexOptions.Compiled | RegexOptions.CultureInvariant);

    /// <summary>
    /// Checks to see if there is a closing bracket for every opening bracket (or any other characters that come in open/close pairs.  Throws SyntaxErrorException if there
    /// is a mismatch in the number of opening/closing of any of the character pairs passed into the method.
    /// </summary>
    /// <param name="openingCharacters">An array of opening characters which start a condition e.g. '['</param>
    /// <param name="closingCharacters">An array of closing characters which must be in the same order (semantically) and size as openingCharacters e.g. if open array element 0 is '[' then closing array element 0 must be ']' </param>
    /// <param name="sql">The string of text to check for equal numbers of opening/closing characters in</param>
    public static void ParityCheckCharacterPairs(char[] openingCharacters, char[] closingCharacters, string sql)
    {
        //it has select sql
        if (string.IsNullOrWhiteSpace(sql)) return;
        for (var i = 0; i < openingCharacters.Length; i++)
            if (openingCharacters[i] ==
                closingCharacters
                    [i]) //if the opening and closing characters are the same character then there should be an even number of them
            {
                //if it is not an even number of them
                if (sql.Count(c => c == openingCharacters[i]) % 2 == 1)
                    throw new SyntaxErrorException(
                        $"Number of instances of character {openingCharacters[i]} are not even (method was informed that this character is both an opening and closing character)");
            }
            else //opening and closing characters are different e.g. '('  and ')', there should be the same number of each of them
            if (sql.Count(c => c == openingCharacters[i]) != sql.Count(c => c == closingCharacters[i]))
            {
                throw new SyntaxErrorException(
                    $"Mismatch in the number of opening '{openingCharacters[i]}' and closing '{closingCharacters[i]}'");
            }
    }

    /// <summary>
    /// Checks to ensure char based parameters contains a value, are not longer than the expected length and contain either single quotes or an @ symbol before performing bracket parity checks
    /// </summary>
    /// <param name="parameter"></param>
    public static void CheckSyntax(ISqlParameter parameter)
    {
        if (string.IsNullOrWhiteSpace(parameter.Value))
            throw new SyntaxErrorException($"Parameter {parameter.ParameterName} does not have a value");

        var isCharBased = parameter.ParameterSQL.ToLower().Contains("char");

        if (isCharBased && parameter.Value.Trim().StartsWith("'"))
        {
            var matchValue = QuotedString.Match(parameter.Value);
            var matchLength = BracketedNumber.Match(parameter.ParameterSQL);

            if (matchValue.Success && matchLength.Success)
            {
                var userSpecifiedLength = int.Parse(matchLength.Value[1..^1]);
                var actualLength = matchValue.Value.Trim().Length - 2;

                if (actualLength > userSpecifiedLength)
                    throw new SyntaxErrorException(
                        $"You created a parameter of length {userSpecifiedLength} ({parameter.ParameterName}) but then put a value in it that is {actualLength} characters long, the parameter with the problem was:{parameter.ParameterName}");
            }
        }

        if (isCharBased && !(parameter.Value.Contains('\'') || parameter.Value.Contains('@')))
            throw new SyntaxErrorException(
                $"Parameter {parameter.ParameterName} looks like it is character based but its value does not contain any single quotes (or at least a reference to another variable)");

        try
        {
            ParityCheckCharacterPairs(new[] { '(', '[', '\'' }, new[] { ')', ']', '\'' }, parameter.ParameterSQL);
            ParityCheckCharacterPairs(new[] { '(', '[', '\'' }, new[] { ')', ']', '\'' }, parameter.Value);
        }
        catch (SyntaxErrorException exception)
        {
            throw new SyntaxErrorException($"Failed to validate the bracket parity of parameter {parameter}",
                exception);
        }


        if (!parameter.GetQuerySyntaxHelper().IsValidParameterName(parameter.ParameterSQL))
            throw new SyntaxErrorException($"parameterSQL is not valid \"{parameter.ParameterSQL}\"");
    }

    /// <summary>
    /// Override in child classes to check the currently configured Sql of the object
    /// </summary>
    /// <param name="notifier"></param>
    public abstract void Check(ICheckNotifier notifier);
}

1	// Copyright (c) The University of Dundee 2018-2019
2	// This file is part of the Research Data Management Platform (RDMP).
3	// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
4	// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
5	// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.
6
7	using System.Data;
8	using System.Linq;
9	using System.Text.RegularExpressions;
10	using Rdmp.Core.Curation.Data;
11	using Rdmp.Core.ReusableLibraryCode.Checks;
12
13	namespace Rdmp.Core.QueryBuilding.SyntaxChecking;
14
15	/// <summary>
16	/// Base class for all Checkers which check the Sql Syntax of an object e.g. an IFilter's WhereSQL
17	/// </summary>
18	public abstract class SyntaxChecker : ICheckable
19	{
20	private static readonly Regex BracketedNumber =	2✔
21	new(@"\([0-9]*\)", RegexOptions.Compiled \| RegexOptions.CultureInvariant);	2✔
22
23	private static readonly Regex QuotedString = new("'[^']*'", RegexOptions.Compiled \| RegexOptions.CultureInvariant);	2✔
24
25	/// <summary>
26	/// Checks to see if there is a closing bracket for every opening bracket (or any other characters that come in open/close pairs. Throws SyntaxErrorException if there
27	/// is a mismatch in the number of opening/closing of any of the character pairs passed into the method.
28	/// </summary>
29	/// <param name="openingCharacters">An array of opening characters which start a condition e.g. '['</param>
30	/// <param name="closingCharacters">An array of closing characters which must be in the same order (semantically) and size as openingCharacters e.g. if open array element 0 is '[' then closing array element 0 must be ']' </param>
31	/// <param name="sql">The string of text to check for equal numbers of opening/closing characters in</param>
32	public static void ParityCheckCharacterPairs(char[] openingCharacters, char[] closingCharacters, string sql)
33	{
34	//it has select sql
35	if (string.IsNullOrWhiteSpace(sql)) return;	4,788✔
36	for (var i = 0; i < openingCharacters.Length; i++)	29,868✔
37	if (openingCharacters[i] ==	10,160✔
38	closingCharacters	10,160✔
39	[i]) //if the opening and closing characters are the same character then there should be an even number of them	10,160✔
40	{
41	//if it is not an even number of them
42	if (sql.Count(c => c == openingCharacters[i]) % 2 == 1)	11,272!
43	throw new SyntaxErrorException(	×
44	$"Number of instances of character {openingCharacters[i]} are not even (method was informed that this character is both an opening and closing character)");	×
45	}
46	else //opening and closing characters are different e.g. '(' and ')', there should be the same number of each of them
47	if (sql.Count(c => c == openingCharacters[i]) != sql.Count(c => c == closingCharacters[i]))	902,960✔
48	{
49	throw new SyntaxErrorException(	2✔
50	$"Mismatch in the number of opening '{openingCharacters[i]}' and closing '{closingCharacters[i]}'");	2✔
51	}
52	}	4,774✔
53
54	/// <summary>
55	/// Checks to ensure char based parameters contains a value, are not longer than the expected length and contain either single quotes or an @ symbol before performing bracket parity checks
56	/// </summary>
57	/// <param name="parameter"></param>
58	public static void CheckSyntax(ISqlParameter parameter)
59	{
60	if (string.IsNullOrWhiteSpace(parameter.Value))	304!
61	throw new SyntaxErrorException($"Parameter {parameter.ParameterName} does not have a value");	×
62
63	var isCharBased = parameter.ParameterSQL.ToLower().Contains("char");	304✔
64
65	if (isCharBased && parameter.Value.Trim().StartsWith("'"))	304✔
66	{
67	var matchValue = QuotedString.Match(parameter.Value);	18✔
68	var matchLength = BracketedNumber.Match(parameter.ParameterSQL);	18✔
69
70	if (matchValue.Success && matchLength.Success)	18✔
71	{
72	var userSpecifiedLength = int.Parse(matchLength.Value[1..^1]);	18✔
73	var actualLength = matchValue.Value.Trim().Length - 2;	18✔
74
75	if (actualLength > userSpecifiedLength)	18!
76	throw new SyntaxErrorException(	×
77	$"You created a parameter of length {userSpecifiedLength} ({parameter.ParameterName}) but then put a value in it that is {actualLength} characters long, the parameter with the problem was:{parameter.ParameterName}");	×
78	}
79	}
80
81	if (isCharBased && !(parameter.Value.Contains('\'') \|\| parameter.Value.Contains('@')))	304!
82	throw new SyntaxErrorException(	×
83	$"Parameter {parameter.ParameterName} looks like it is character based but its value does not contain any single quotes (or at least a reference to another variable)");	×
84
85	try
86	{
87	ParityCheckCharacterPairs(new[] { '(', '[', '\'' }, new[] { ')', ']', '\'' }, parameter.ParameterSQL);	304✔
88	ParityCheckCharacterPairs(new[] { '(', '[', '\'' }, new[] { ')', ']', '\'' }, parameter.Value);	304✔
89	}	304✔
90	catch (SyntaxErrorException exception)	×
91	{
92	throw new SyntaxErrorException($"Failed to validate the bracket parity of parameter {parameter}",	×
93	exception);	×
94	}
95
96
97	if (!parameter.GetQuerySyntaxHelper().IsValidParameterName(parameter.ParameterSQL))	304!
98	throw new SyntaxErrorException($"parameterSQL is not valid \"{parameter.ParameterSQL}\"");	×
99	}	304✔
100
101	/// <summary>
102	/// Override in child classes to check the currently configured Sql of the object
103	/// </summary>
104	/// <param name="notifier"></param>
105	public abstract void Check(ICheckNotifier notifier);
106	}

HicServices / RDMP / 6245535001

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