aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorEugene Triguba <eugenetriguba@gmail.com>2020-08-01 11:20:39 -0500
committerEugene Triguba <eugenetriguba@gmail.com>2020-08-01 11:20:39 -0500
commit5ac52d231e56f60a22ba3f755415c4aa43a14d83 (patch)
tree28bafdbce1350e77f51bff4d01b5e4e61ec4eca7
parentMerge branch 'dev' into dev (diff)
downloadconfig-file-5ac52d231e56f60a22ba3f755415c4aa43a14d83.zip
Add tests to parse_value and fix bugs in it
-rw-r--r--config_file/parsers/parse_value.py78
-rw-r--r--tests/test_parse_value.py191
2 files changed, 230 insertions, 39 deletions
diff --git a/config_file/parsers/parse_value.py b/config_file/parsers/parse_value.py
index aa8d1fe..28f1ccb 100644
--- a/config_file/parsers/parse_value.py
+++ b/config_file/parsers/parse_value.py
@@ -22,10 +22,22 @@ parse_value("-5") -> -5
import ast
import re
from distutils.util import strtobool
+from typing import Any
-def parse_value(value):
- if type(value) is dict:
+def parse_value(value: Any) -> Any:
+ """Parse a value into native type.
+
+ Args:
+ value: The value to parse.
+
+ Returns:
+ The parsed value, if it could be parsed
+ as a dictionary, list, int, float, or bool.
+ Otherwise, it simply returns the original
+ passed in value.
+ """
+ if isinstance(value, dict):
parsed = {}
for item in value:
@@ -33,7 +45,7 @@ def parse_value(value):
return parsed
- if type(value) is list:
+ if isinstance(value, list):
parsed = []
for item in value:
@@ -42,92 +54,108 @@ def parse_value(value):
return parsed
if can_be_parsed_as_int(value):
- return int(value)
+ return int(value.strip()) if isinstance(value, str) else int(value)
if can_be_parsed_as_float(value):
- return float(value)
+ return float(value.strip()) if isinstance(value, str) else float(value)
if can_be_parsed_as_bool(value):
- return value if type(value) is bool else bool(strtobool(value))
+ return bool(value) if isinstance(value, bool) else bool(strtobool(value))
if can_be_parsed_as_dict(value):
- return parse_value(ast.literal_eval(value))
+ return parse_value(ast.literal_eval(value.strip()))
if can_be_parsed_as_list(value):
- return parse_value(ast.literal_eval(value))
+ return parse_value(ast.literal_eval(value.strip()))
return value
-def can_be_parsed_as_int(value) -> bool:
- if type(value) is int:
+def can_be_parsed_as_int(value: Any) -> bool:
+ """Check whether a value can be parsed as a integer.
+
+ Args:
+ value: The value to check if it can be parsed as an integer.
+
+ Returns:
+ True if we can parse the value as a integer. False otherwise.
+ """
+ if isinstance(value, int) and not type(value) is bool:
return True
- if type(value) is not str:
+ if not isinstance(value, str):
return False
+ value = value.strip()
+
if value.startswith("-"):
return value[1:].isdigit()
return value.isdigit()
-def can_be_parsed_as_float(value) -> bool:
+def can_be_parsed_as_float(value: Any) -> bool:
FLOAT_REGEX = r"^\d*\.\d+$"
- if type(value) is float:
+ if isinstance(value, float):
return True
- if type(value) is not str:
+ if not isinstance(value, str):
return False
+ value = value.strip()
+
if value.startswith("-"):
value = value[1:]
return bool(re.match(FLOAT_REGEX, value))
-def can_be_parsed_as_bool(value) -> bool:
- if type(value) is bool:
+def can_be_parsed_as_bool(value: Any) -> bool:
+ if isinstance(value, bool):
return True
- if type(value) is not str:
+ if not isinstance(value, str):
return False
- return value.lower() == "true" or value.lower() == "false"
+ value = value.lower().strip()
+
+ return value == "true" or value == "false"
-def can_be_parsed_as_dict(value) -> bool:
- if type(value) is dict:
+def can_be_parsed_as_dict(value: Any) -> bool:
+ if isinstance(value, dict):
return True
- if type(value) is not str:
+ if not isinstance(value, str):
return False
value = value.strip()
+
if value[0] == "{" and value[-1] == "}":
try:
ast.literal_eval(value)
return True
- except SyntaxError:
+ except Exception:
return False
return False
def can_be_parsed_as_list(value) -> bool:
- if type(value) is dict:
+ if isinstance(value, list):
return True
- if type(value) is not str:
+ if not isinstance(value, str):
return False
value = value.strip()
+
if value[0] == "[" and value[-1] == "]":
try:
ast.literal_eval(value)
return True
- except SyntaxError:
+ except Exception:
return False
return False
diff --git a/tests/test_parse_value.py b/tests/test_parse_value.py
index 63ce6bb..735abc3 100644
--- a/tests/test_parse_value.py
+++ b/tests/test_parse_value.py
@@ -1,6 +1,15 @@
+from datetime import datetime
+
import pytest
-from config_file.parsers.parse_value import can_be_parsed_as_bool, parse_value
+from config_file.parsers.parse_value import (
+ can_be_parsed_as_bool,
+ can_be_parsed_as_dict,
+ can_be_parsed_as_float,
+ can_be_parsed_as_int,
+ can_be_parsed_as_list,
+ parse_value,
+)
@pytest.mark.parametrize(
@@ -8,37 +17,191 @@ from config_file.parsers.parse_value import can_be_parsed_as_bool, parse_value
[
("5", 5),
("-5", -5),
+ ("0", 0),
("-234.5", -234.5),
("35.5", 35.5),
("TRUE", True),
("true", True),
("false", False),
- ("blah", "blah"),
- (343, 343),
- (3.2, 3.2),
- (True, True),
+ ],
+)
+def test_parse_value_parses_ints_floats_and_bools(test_input, expected):
+ """
+ config_file.parsers.parse_value
+
+ Parses string values that contain ints, floats, and booleans into
+ their native representation.
+ """
+ assert parse_value(test_input) == expected
+
+
+@pytest.mark.parametrize(
+ "test_input,expected",
+ [
({"blah": "5"}, {"blah": 5}),
(
{"blah": {"blah2": {"blah3": "fAlSe"}, "abc": "5.25", "boo": "tRuE"}},
{"blah": {"blah2": {"blah3": False}, "abc": 5.25, "boo": True}},
),
+ ("{ 'key': '5', 'key2': 'fAlSE' }", {"key": 5, "key2": False}),
(
["5", "4.4", "faLSe", "trUE", "foo", "-5", "-5.2"],
[5, 4.4, False, True, "foo", -5, -5.2],
),
- ("[1, 2, 3]", [1, 2, 3]),
- ("[True, [1, 5], {}, 5.5]", [True, [1, 5], {}, 5.5]),
- ("{ 'key': '5', 'key2': 'fAlSE' }", {"key": 5, "key2": False}),
+ (" [1, 2, 3] ", [1, 2, 3]),
+ (" [True, [1, 5], {}, 5.5]", [True, [1, 5], {}, 5.5]),
],
)
-def test_parse_value(test_input, expected):
+def test_parse_value_parses_dicts_and_lists(test_input, expected):
+ """
+ config_file.parsers.parse_value
+
+ Parses string values that contain dictionaries or lists into
+ their native representation.
+ """
assert parse_value(test_input) == expected
-def test_can_be_parsed_as_bool():
+@pytest.mark.parametrize("test_input", ["blah", datetime(2020, 1, 1)])
+def test_parse_value_returns_values_that_cannot_be_parsed(test_input):
+ """
+ config_file.parsers.parse_value
+
+ If a value is given that cannot be parsed by parse_value,
+ it should simply return that value back.
+ """
+ assert parse_value(test_input) == test_input
+
+
+@pytest.mark.parametrize(
+ "test_input",
+ [(343, 343), (3.2, 3.2), (True, True), (False, False), ({}, {}), ([], [])],
+)
+def test_parse_value_returns_values_that_are_already_in_their_native_type(test_input):
+ """
+ config_file.parsers.parse_value
+
+ Returns back the inputted value if it is already in its native type.
+ """
+ assert parse_value(test_input) == test_input
+
+
+@pytest.mark.parametrize("value", [-1, 0, 1, "1", "-1", " 0 "])
+def test_values_that_can_be_parsed_as_int(value):
+ """
+ config_file.parsers.can_be_parsed_as_int
+
+ Returns True for values that can be parsed as an int.
+ """
+ assert can_be_parsed_as_int(value)
+
+
+@pytest.mark.parametrize(
+ "value", [True, False, 5.5, "5.5", [], {}, "ruff", datetime.now()]
+)
+def test_values_that_cannot_be_parsed_as_int(value):
+ """
+ config_file.parsers.can_be_parsed_as_int
+
+ Returns False for values that cannot be parsed as an int.
+ """
+ assert not can_be_parsed_as_int(value)
+
+
+@pytest.mark.parametrize("value", [5.5, -1.2, ".1", "5.5", " 1.1 ", "-0.0", "0.0"])
+def test_values_that_can_be_parsed_as_float(value):
"""
- This is the section not being covered in the parse_value.py
- file from test_parse_value, but I don't think it's reachable
- from using it.
+ config_file.parsers.can_be_parsed_as_float
+
+ Returns True for values that can be parsed as an float.
+ """
+ assert can_be_parsed_as_float(value)
+
+
+@pytest.mark.parametrize(
+ "value",
+ [
+ 545,
+ 0,
+ -3,
+ "1",
+ "-1",
+ True,
+ False,
+ " 0 ",
+ "0..0",
+ [],
+ {},
+ "ruff",
+ datetime.now(),
+ ],
+)
+def test_values_that_cannot_be_parsed_as_float(value):
+ """
+ config_file.parsers.can_be_parsed_as_float
+
+ Returns False for values that cannot be parsed as an float.
+ """
+ assert not can_be_parsed_as_float(value)
+
+
+@pytest.mark.parametrize(
+ "value", [True, False, "false", "true", "TRUE", "FALSE", " FALSE ", " TRUE "]
+)
+def test_values_that_can_be_parsed_as_bool(value):
+ """
+ config_file.parsers.can_be_parsed_as_bool
+
+ Returns True for values that can be parsed as a bool.
+ """
+ assert can_be_parsed_as_bool(value)
+
+
+@pytest.mark.parametrize("value", [0, 1, -1, 5.3, "ruff", {}, [], datetime.now()])
+def test_values_that_cannot_be_parsed_as_bool(value):
+ """
+ config_file.parsers.can_be_parsed_as_bool
+
+ Returns False for values that cannot be parsed as a bool.
+ """
+ assert not can_be_parsed_as_bool(value)
+
+
+@pytest.mark.parametrize("value", [{}, {"hello": 5}, "{}", " { } ", "{'test': 5}"])
+def test_values_that_can_be_parsed_as_dict(value):
+ """
+ config_file.parsers.can_be_parsed_as_dict
+
+ Returns True for values that can be parsed as a dict.
+ """
+ assert can_be_parsed_as_dict(value)
+
+
+@pytest.mark.parametrize("value", [0, 5, -1, 5.5, [], "ruff", " { invalid } "])
+def test_values_that_cannot_be_parsed_as_dict(value):
+ """
+ config_file.parsers.can_be_parsed_as_dict
+
+ Returns False for values that cannot be parsed as a dict.
+ """
+ assert not can_be_parsed_as_dict(value)
+
+
+@pytest.mark.parametrize("value", [[], [1, 2, True, 5.5], "[]", " [] ", " [1, 2, 3]"])
+def test_values_that_can_be_parsed_as_list(value):
+ """
+ config_file.parsers.can_be_parsed_as_list
+
+ Returns True for values that can be parsed as a list.
+ """
+ assert can_be_parsed_as_list(value)
+
+
+@pytest.mark.parametrize("value", [0, 5, -1, 5.5, {}, "ruff", " [ invalid ] "])
+def test_values_that_cannot_be_parsed_as_list(value):
+ """
+ config_file.parsers.can_be_parsed_as_list
+
+ Returns False for values that cannot be parsed as a list.
"""
- assert can_be_parsed_as_bool(5) is False
+ assert not can_be_parsed_as_list(value)