diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/qc/test_cells.py | 85 | ||||
| -rw-r--r-- | tests/qc/test_header.py | 58 |
2 files changed, 141 insertions, 2 deletions
diff --git a/tests/qc/test_cells.py b/tests/qc/test_cells.py index d4ef911..46aeb64 100644 --- a/tests/qc/test_cells.py +++ b/tests/qc/test_cells.py @@ -1,12 +1,18 @@ """Test that values in cells within a line fulfill the required criteria""" import pytest +from random import randint from hypothesis import given from hypothesis import strategies as st +from quality_control.errors import InvalidValue from quality_control.errors import InvalidCellValue -from quality_control.average import valid_value as avg_valid_value -from quality_control.standard_error import valid_value as se_valid_value +from quality_control.average import ( + valid_value as avg_valid_value, + invalid_value as avg_invalid_value) +from quality_control.standard_error import ( + valid_value as se_valid_value, + invalid_value as se_invalid_value) @given(num_str=st.from_regex( r"^(?!([0-9]+\.([0-9]{3}|[0-9]{6,}))).*", fullmatch=True)) @@ -51,3 +57,78 @@ def test_cell_standard_error_value_pass_if_six_or_more_decimal_places(num_str): assert ( isinstance(processed, float) and processed == float(num_str)) + +## ================================================================================ + +@given(num_str=st.from_regex( + r"^(?!([0-9]+\.([0-9]{3}|[0-9]{6,}))).*", fullmatch=True)) +def test_cell_value_errors_with_invalid_inputs2(num_str): + """ + GIVEN: `num_str` is an arbitrary string that is an invalid input, + WHEN: `num_str` is provided as an argument to `*_invalid_value` functions, + THEN: The `*_invalid_value` functions return a + `quality_control.errors.InvalidValue` object which holds the error + information. + """ + assert avg_invalid_value(0, 0, num_str) == InvalidValue( + 0, 0, num_str, ( + f"Invalid value '{num_str}'. Expected string representing a number " + "with exactly three decimal places.")) + assert se_invalid_value(0, 0, num_str) == InvalidValue( + 0, 0, num_str, ( + f"Invalid value '{num_str}'. Expected string representing a number " + "with at least six decimal places.")) + +@given(num_str=st.from_regex( + r"^[0-9]+\.([0-9]{1,2}|[0-9]{4,}$)", fullmatch=True)) +def test_cell_average_value_errors_if_not_three_decimal_places2(num_str): + """ + GIVEN: `num_str` is a string representing a number with less than or more + than three decimal places, e.g. 2.92, 39.483732 + WHEN: `num_str` is provided as an argument to `avg_invalid_value` function, + THEN: `avg_invalid_value` returns a `quality_control.errors.InvalidValue` + object with the information about the placement of the invalid value. + """ + line, col = randint(0, 100), randint(0, 20) + assert avg_invalid_value(line, col, num_str) == InvalidValue( + line, col, num_str, ( + f"Invalid value '{num_str}'. Expected string representing a number " + "with exactly three decimal places.")) + +@given(num_str=st.from_regex(r"^[0-9]+\.[0-9]{3}$", fullmatch=True)) +def test_cell_average_value_pass_if_three_decimal_places(num_str): + """ + GIVEN: `num_str` is a string representing a number with exactly three + decimal places, e.g. 2.924, 39.483 + WHEN: `num_str` is provided as an argument to `avg_invalid_value` function, + THEN: `avg_invalid_value` returns `None` + """ + line, col = randint(0, 100), randint(0, 20) + assert avg_invalid_value(line, col, num_str) is None + +@given(num_str=st.from_regex(r"^[0-9]+\.([0-9]{0,5}$)", fullmatch=True)) +def test_cell_standard_error_value_errors_if_less_than_six_decimal_places2(num_str): + """ + GIVEN: `num_str` is a string representing a number with less than six + decimal places, e.g. 2.9, 39.4837 + WHEN: `num_str` is provided as an argument to `se_invalid_value` function, + THEN: `se_invalid_value` returns a `quality_control.errors.InvalidValue` + object with the information about the placement of the invalid value. + """ + line, col = randint(0, 100), randint(0, 20) + assert se_invalid_value(line, col, num_str) == InvalidValue( + line, col, num_str, ( + f"Invalid value '{num_str}'. Expected string representing a number " + "with at least six decimal places.")) + + +@given(num_str=st.from_regex(r"^[0-9]+\.[0-9]{6,}$", fullmatch=True)) +def test_cell_standard_error_value_pass_if_six_or_more_decimal_places(num_str): + """ + GIVEN: `num_str` is a string representing a number with six or more + decimal places, e.g. 2.938434, 39.4837343 + WHEN: `num_str` is provided as an argument to `se_invalid_value` function, + THEN: `se_invalid_value` returns `None` + """ + line, col = randint(0, 100), randint(0, 20) + assert se_invalid_value(line, col, num_str) is None diff --git a/tests/qc/test_header.py b/tests/qc/test_header.py index 6ca9376..f860a71 100644 --- a/tests/qc/test_header.py +++ b/tests/qc/test_header.py @@ -4,7 +4,10 @@ from hypothesis import given from hypothesis import strategies as st from quality_control.headers import valid_header +from quality_control.errors import InvalidValue, DuplicateHeading from quality_control.errors import DuplicateHeader, InvalidHeaderValue +from quality_control.headers import ( + invalid_header, invalid_headings, duplicate_headings) @given(headers=st.lists(st.text(max_size=10))) def test_valid_header_errors_with_invalid_headers(headers): @@ -31,3 +34,58 @@ def test_valid_header_fails_with_duplicate_headers(strains, headers): """Check that parsing fails if any header is duplicated""" with pytest.raises(DuplicateHeader): valid_header(strains, headers) + +## ============================================================ + +@given(headers=st.lists(st.text(max_size=10), max_size=1)) +def test_invalid_header_with_list_of_one_value(headers): + assert invalid_header(0, headers) == InvalidValue( + 0, 0, "<TAB>".join(headers), + "The header MUST contain at least 2 columns") + +@given(headings=st.lists(st.text(min_size=2, max_size=10), min_size=2)) +def test_invalid_headings_with_invalid_inputs(headings): + "Verify that the check for header validity works" + assert invalid_headings(0, ("BXD1", "BXD2", "BXD3"), headings) == tuple( + InvalidValue(0, col, heading, f"'{heading}' not a valid strain.") + for col, heading in enumerate(headings, start=2)) + +@pytest.mark.parametrize( + "strains,headers", [ + (("BXD1", "BXD2", "BXD3"), ("ProbeSet", "BXD3", "BXD1")), + (("AStrain", "AnotherStrain", "YetAnotherStrain"), + ("Individual", "AStrain", "AnotherStrain", "YetAnotherStrain"))]) +def test_invalid_header_with_valid_headers(strains, headers): + "Verify that the check for header validity works" + assert invalid_header(0, headers) == None + +@pytest.mark.parametrize( + "strains,headings", [ + (("BXD1", "BXD2", "BXD3"), ("BXD3", "BXD1")), + (("AStrain", "AnotherStrain", "YetAnotherStrain"), + ("AStrain", "AnotherStrain", "YetAnotherStrain"))]) +def test_invalid_headings_with_valid_headings(strains, headings): + "Verify that the check for header validity works" + assert invalid_headings(0, strains, headings) == tuple() + +@pytest.mark.parametrize( + "headers,repeated", [ + (("ProbeSet", "BXD3", "BXD1", "BXD1"), {"BXD1": (3, 4)}), + (("Individual", "AStrain", "AnotherStrain", "YetAnotherStrain", + "AStrain"), {"AStrain": (2, 5)})]) +def test_duplicate_headers_with_repeated_column_headings(headers, repeated): + """Check that parsing fails if any header is duplicated""" + assert duplicate_headings(0, headers) == tuple( + DuplicateHeading(0, head, cols, ( + f"Heading '{head}', is repeated in columns " + f"{','.join(str(i) for i in cols)}")) + for head, cols in repeated.items()) + +@pytest.mark.parametrize( + "headers", [ + (("ProbeSet", "BXD3", "BXD1")), + (("Individual", "AStrain", "AnotherStrain", "YetAnotherStrain",))]) +def test_duplicate_headers_with_unique_column_headings(headers): + """Check that parsing fails if any header is duplicated""" + assert duplicate_headings(0, headers) == tuple() + |