lms.util.testing 

 1import re
 2import typing
 3
 4import edq.testing.asserts
 5import edq.testing.unittest
 6import edq.util.json
 7
 8import lms.model.testdata.quizzes
 9
10ID_SUBS: typing.List[typing.Tuple[re.Pattern, str]] = [
11    (re.compile(r'^id: \d+'), 'id: <ID>'),  # Text
12    (re.compile(r'^\d+\t'), "<ID>\t"),  # Table
13    (re.compile(r'"id": "\d+"'), '"id": "<ID>"'),  # JSON
14    (re.compile(r' \(\d{1,2}\)'), ' (<ID>)'),  # Labels with Small IDs
15]
16
17def cli_assert_normalize_ids(test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: typing.Any) -> None:
18    """
19    Normalize IDs (as output from a standard CLI,
20    and then use edq.testing.asserts.content_equals_normalize().
21    """
22
23    for (pattern, replacement) in ID_SUBS:
24        expected = re.sub(pattern, replacement, expected)
25        actual = re.sub(pattern, replacement, actual)
26
27    edq.testing.asserts.content_equals_normalize(test, expected, actual)
28
29def cli_assert_quiz_groups(test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: typing.Any) -> None:
30    """
31    Verify that the quiz groups (in JSON) matches the expected test quiz groups.
32    """
33
34    expected_list = edq.util.json.loads(edq.util.json.dumps(lms.model.testdata.quizzes.ORDERED_QUIZ_GROUPS['Regular Expressions']))
35    actual_list = edq.util.json.loads(actual)
36
37    # Remove an extra field.
38    for group in expected_list:
39        group.pop('extra_fields', None)
40
41    test.assertListEqual(expected_list, actual_list)
42
43def cli_assert_quiz_questions(test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: typing.Any) -> None:
44    """
45    Verify that the quiz questions (in JSON) matches the expected test quiz questions.
46    """
47
48    expected_list = edq.util.json.loads(edq.util.json.dumps(lms.model.testdata.quizzes.ORDERED_QUIZ_QUESTIONS['Regular Expressions']))
49    actual_list = edq.util.json.loads(actual)
50
51    # Remove extra fields.
52    for question in expected_list:
53        question.pop('extra_fields', None)
54        question.pop('group_id', None)
55        question.pop('resources', None)
56
57    test.assertListEqual(expected_list, actual_list)
ID_SUBS: List[Tuple[re.Pattern, str]] = [(re.compile('^id: \\d+'), 'id: <ID>'), (re.compile('^\\d+\\t'), '<ID>\t'), (re.compile('"id": "\\d+"'), '"id": "<ID>"'), (re.compile(' \\(\\d{1,2}\\)'), ' (<ID>)')]
def cli_assert_normalize_ids( test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: Any) -> None: 
18def cli_assert_normalize_ids(test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: typing.Any) -> None:
19    """
20    Normalize IDs (as output from a standard CLI,
21    and then use edq.testing.asserts.content_equals_normalize().
22    """
23
24    for (pattern, replacement) in ID_SUBS:
25        expected = re.sub(pattern, replacement, expected)
26        actual = re.sub(pattern, replacement, actual)
27
28    edq.testing.asserts.content_equals_normalize(test, expected, actual)

Normalize IDs (as output from a standard CLI, and then use edq.testing.asserts.content_equals_normalize().

def cli_assert_quiz_groups( test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: Any) -> None: 
30def cli_assert_quiz_groups(test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: typing.Any) -> None:
31    """
32    Verify that the quiz groups (in JSON) matches the expected test quiz groups.
33    """
34
35    expected_list = edq.util.json.loads(edq.util.json.dumps(lms.model.testdata.quizzes.ORDERED_QUIZ_GROUPS['Regular Expressions']))
36    actual_list = edq.util.json.loads(actual)
37
38    # Remove an extra field.
39    for group in expected_list:
40        group.pop('extra_fields', None)
41
42    test.assertListEqual(expected_list, actual_list)

Verify that the quiz groups (in JSON) matches the expected test quiz groups.

def cli_assert_quiz_questions( test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: Any) -> None: 
44def cli_assert_quiz_questions(test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: typing.Any) -> None:
45    """
46    Verify that the quiz questions (in JSON) matches the expected test quiz questions.
47    """
48
49    expected_list = edq.util.json.loads(edq.util.json.dumps(lms.model.testdata.quizzes.ORDERED_QUIZ_QUESTIONS['Regular Expressions']))
50    actual_list = edq.util.json.loads(actual)
51
52    # Remove extra fields.
53    for question in expected_list:
54        question.pop('extra_fields', None)
55        question.pop('group_id', None)
56        question.pop('resources', None)
57
58    test.assertListEqual(expected_list, actual_list)

Verify that the quiz questions (in JSON) matches the expected test quiz questions.