Fix unit tests for renamed classes

Author: handrews

tests/test_ptrtemplates.py

@@ -3,12 +3,12 @@
 import pytest
 
 from oascomply.ptrtemplates import (
-    JSONPointerTemplate,
-    InvalidJSONPointerTemplateError,
-    JSONPointerTemplateEvaluationError,
-    RelativeJSONPointerTemplate,
-    InvalidRelativeJSONPointerTemplateError,
-    RelativeJSONPointerTemplateEvaluationError,
+    JsonPtrTemplate,
+    InvalidJsonPtrTemplateError,
+    JsonPtrTemplateEvaluationError,
+    RelJsonPtrTemplate,
+    InvalidRelJsonPtrTemplateError,
+    RelJsonPtrTemplateEvaluationError,
 )
 
 
@@ -22,7 +22,7 @@
 def test_escape(unescaped, escaped):
     import sys
     sys.stderr.write(f"{unescaped!r} {escaped!r}")
-    assert JSONPointerTemplate.escape(unescaped) == escaped
+    assert JsonPtrTemplate.escape(unescaped) == escaped
 
 
 @pytest.mark.parametrize('escaped,unescaped', (
@@ -35,7 +35,7 @@ def test_escape(unescaped, escaped):
 def test_unescape(escaped, unescaped):
     import sys
     sys.stderr.write(f"{escaped!r} {unescaped!r}")
-    assert JSONPointerTemplate.unescape(escaped) == unescaped
+    assert JsonPtrTemplate.unescape(escaped) == unescaped
 
 
 @pytest.mark.parametrize('template_str,components', (
@@ -54,7 +54,7 @@ def test_unescape(escaped, unescaped):
     ('/bar#', [jschon.JSONPointer('/bar#')]),
 ))
 def test_constructor(template_str, components):
-    jpt = JSONPointerTemplate(template_str)
+    jpt = JsonPtrTemplate(template_str)
     assert jpt._components == components
 
 
@@ -68,10 +68,10 @@ def test_constructor(template_str, components):
 ))
 def test_constructor_errors(template_str):
     with pytest.raises(
-        InvalidJSONPointerTemplateError,
-        match='not a valid JSONPointerTemplate',
+        InvalidJsonPtrTemplateError,
+        match='not a valid JsonPtrTemplate',
     ):
-        JSONPointerTemplate(template_str)
+        JsonPtrTemplate(template_str)
 
 
 TEST_DOCUMENT = jschon.JSON({
@@ -85,13 +85,13 @@ def test_constructor_errors(template_str):
 
 @pytest.mark.parametrize('template,output', (
     (
-        JSONPointerTemplate(''),
+        JsonPtrTemplate(''),
         [(jschon.JSONPointer(''), TEST_DOCUMENT, {}, None)],
     ), (
-        JSONPointerTemplate('/a/0'),
+        JsonPtrTemplate('/a/0'),
         [(jschon.JSONPointer('/a/0'), TEST_DOCUMENT['a'][0], {}, None)],
     ), (
-        JSONPointerTemplate('/e/{key}'),
+        JsonPtrTemplate('/e/{key}'),
         [
             (
                 jschon.JSONPointer(f'/e/{key}'),
@@ -101,7 +101,7 @@ def test_constructor_errors(template_str):
             ) for key in TEST_DOCUMENT['e']
         ],
     ), (
-        JSONPointerTemplate('/e/{key}#'),
+        JsonPtrTemplate('/e/{key}#'),
         [
             (
                 jschon.JSONPointer(f'/e/{key}'),
@@ -111,7 +111,7 @@ def test_constructor_errors(template_str):
             ) for key in TEST_DOCUMENT['e']
         ],
     ), (
-        JSONPointerTemplate('/e/{key1}/{index}'),
+        JsonPtrTemplate('/e/{key1}/{index}'),
         list(chain.from_iterable([
             [
                 (
@@ -123,7 +123,7 @@ def test_constructor_errors(template_str):
             ] for key1 in TEST_DOCUMENT['e'].keys()
         ])),
     ), (
-        JSONPointerTemplate('/nope/{whatever}'),
+        JsonPtrTemplate('/nope/{whatever}'),
         [],
     )
 ))
@@ -140,47 +140,47 @@ def test_evaluation(template, output):
     ('/a/0/{scalar}', 'Cannot match template variable', True),
 ))
 def test_evaluation_errors(template, match, require):
-    jpt = JSONPointerTemplate(template)
-    with pytest.raises(JSONPointerTemplateEvaluationError, match=match):
+    jpt = JsonPtrTemplate(template)
+    with pytest.raises(JsonPtrTemplateEvaluationError, match=match):
         list(jpt.evaluate(TEST_DOCUMENT, require_match=require))
 
 
 @pytest.mark.parametrize('template_str,relptr,jptemplate', (
     ('1+3#', jschon.RelativeJSONPointer('1+3#'), None),
-    ('0/foo', jschon.RelativeJSONPointer('0'), JSONPointerTemplate('/foo')),
+    ('0/foo', jschon.RelativeJSONPointer('0'), JsonPtrTemplate('/foo')),
     (
         '1/{bar}#',
         jschon.RelativeJSONPointer('1'),
-        JSONPointerTemplate('/{bar}#'),
+        JsonPtrTemplate('/{bar}#'),
     ),
 ))
 def test_rel_constructor(template_str, relptr, jptemplate):
-    rjpt = RelativeJSONPointerTemplate(template_str)
+    rjpt = RelJsonPtrTemplate(template_str)
     assert rjpt._relptr == relptr
     assert rjpt._jptemplate == jptemplate
 
 
 @pytest.mark.parametrize('template_str,match', (
     ('0#/foo', "Can't use '#'"),
-    ('stuff/nonsense', 'not a valid RelativeJSONPointerTemplate'),
-    ('0/{bar}#/foo', 'not a valid RelativeJSONPointerTemplate'),
+    ('stuff/nonsense', 'not a valid RelJsonPtrTemplate'),
+    ('0/{bar}#/foo', 'not a valid RelJsonPtrTemplate'),
 ))
 def test_rel_constructor_errors(template_str, match):
-    with pytest.raises(InvalidRelativeJSONPointerTemplateError, match=match):
-        RelativeJSONPointerTemplate(template_str)
+    with pytest.raises(InvalidRelJsonPtrTemplateError, match=match):
+        RelJsonPtrTemplate(template_str)
 
 
 @pytest.mark.parametrize('template,start,output', (
     (
-        RelativeJSONPointerTemplate('0+1'),
+        RelJsonPtrTemplate('0+1'),
         jschon.JSONPointer('/a/1').evaluate(TEST_DOCUMENT),
         [(jschon.RelativeJSONPointer('0+1'), TEST_DOCUMENT['a'][2], {}, None)],
     ), (
-        RelativeJSONPointerTemplate('1#'),
+        RelJsonPtrTemplate('1#'),
         jschon.JSONPointer('/e/f').evaluate(TEST_DOCUMENT),
         [(jschon.RelativeJSONPointer('1#'), TEST_DOCUMENT['e'], {}, 'e')],
     ), (
-        RelativeJSONPointerTemplate('0/{var}'),
+        RelJsonPtrTemplate('0/{var}'),
         jschon.JSONPointer('/e/i').evaluate(TEST_DOCUMENT),
         [
             (
@@ -197,7 +197,7 @@ def test_rel_constructor_errors(template_str, match):
             ),
         ],
     ), (
-        RelativeJSONPointerTemplate('0/nope/{whatever}'),
+        RelJsonPtrTemplate('0/nope/{whatever}'),
         TEST_DOCUMENT,
         [],
     )
@@ -208,17 +208,17 @@ def test_rel_evaluation(template, start, output):
 
 @pytest.mark.parametrize('template,start,match,require', (
     (
-        RelativeJSONPointerTemplate('1/{whatever}'),
+        RelJsonPtrTemplate('1/{whatever}'),
         TEST_DOCUMENT,
         'Could not evaluate origin',
         False,
     ), (
-        RelativeJSONPointerTemplate('0/x'),
+        RelJsonPtrTemplate('0/x'),
         TEST_DOCUMENT,
         r'Path .* not found .* \(after applying',
         True,
     )
 ))
 def test_rel_evaluation_errors(template, start, match, require):
-    with pytest.raises(RelativeJSONPointerTemplateEvaluationError, match=match):
+    with pytest.raises(RelJsonPtrTemplateEvaluationError, match=match):
         list(template.evaluate(start, require_match=require))