From 5aadf92767614b7bd8e2ef677085410ac359e5e8 Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Sat, 25 Oct 2014 08:18:39 +1300 Subject: Nicer way to specify patterns read for file - just use a path --- test/test_language.py | 112 ++++++++++++++++++++++---------------------------- 1 file changed, 50 insertions(+), 62 deletions(-) (limited to 'test/test_language.py') diff --git a/test/test_language.py b/test/test_language.py index 5e9176ab..73b4583f 100644 --- a/test/test_language.py +++ b/test/test_language.py @@ -298,11 +298,11 @@ class TestHeaders: assert v2.value.val == v3.value.val def test_shortcuts(self): - assert language.parse_response({}, "400:c'foo'").headers[0].key.val == "Content-Type" - assert language.parse_response({}, "400:l'foo'").headers[0].key.val == "Location" + assert language.parse_response("400:c'foo'").headers[0].key.val == "Content-Type" + assert language.parse_response("400:l'foo'").headers[0].key.val == "Location" - assert 'Android' in language.parse_request({}, "get:/:ua").headers[0].value.val - assert language.parse_request({}, "get:/:ua").headers[0].key.val == "User-Agent" + assert 'Android' in language.parse_request("get:/:ua").headers[0].value.val + assert language.parse_request("get:/:ua").headers[0].key.val == "User-Agent" class TestShortcutUserAgent: @@ -336,7 +336,7 @@ class Test_Action: assert l[0].offset == 0 def test_resolve(self): - r = language.parse_request({}, 'GET:"/foo"') + r = language.parse_request('GET:"/foo"') e = language.DisconnectAt("r") ret = e.resolve(r, {}) assert isinstance(ret.offset, int) @@ -352,9 +352,9 @@ class Test_Action: class TestDisconnects: def test_parse_response(self): - a = language.parse_response({}, "400:d0").actions[0] + a = language.parse_response("400:d0").actions[0] assert a.spec() == "d0" - a = language.parse_response({}, "400:dr").actions[0] + a = language.parse_response("400:dr").actions[0] assert a.spec() == "dr" def test_at(self): @@ -377,12 +377,12 @@ class TestDisconnects: class TestInject: def test_parse_response(self): - a = language.parse_response({}, "400:ir,@100").actions[0] + a = language.parse_response("400:ir,@100").actions[0] assert a.offset == "r" assert a.value.datatype == "bytes" assert a.value.usize == 100 - a = language.parse_response({}, "400:ia,@100").actions[0] + a = language.parse_response("400:ia,@100").actions[0] assert a.offset == "a" def test_at(self): @@ -397,7 +397,7 @@ class TestInject: def test_serve(self): s = cStringIO.StringIO() - r = language.parse_response({}, "400:i0,'foo'") + r = language.parse_response("400:i0,'foo'") assert language.serve(r, s, {}) def test_spec(self): @@ -430,7 +430,7 @@ class TestPauses: assert v.offset == "a" def test_request(self): - r = language.parse_response({}, '400:p10,10') + r = language.parse_response('400:p10,10') assert r.actions[0].spec() == "p10,10" def test_spec(self): @@ -444,30 +444,24 @@ class TestPauses: class TestRequest: - def test_file(self): - p = tutils.test_data.path("data") - d = dict(staticdir=p) - r = language.parse_request(d, "+request") - assert r.path.values({})[0][:] == "/foo" - def test_nonascii(self): - tutils.raises("ascii", language.parse_request, {}, "get:\xf0") + tutils.raises("ascii", language.parse_request, "get:\xf0") def test_err(self): - tutils.raises(language.ParseException, language.parse_request, {}, 'GET') + tutils.raises(language.ParseException, language.parse_request, 'GET') def test_simple(self): - r = language.parse_request({}, 'GET:"/foo"') + r = language.parse_request('GET:"/foo"') assert r.method.string() == "GET" assert r.path.string() == "/foo" - r = language.parse_request({}, 'GET:/foo') + r = language.parse_request('GET:/foo') assert r.path.string() == "/foo" - r = language.parse_request({}, 'GET:@1k') + r = language.parse_request('GET:@1k') assert len(r.path.string()) == 1024 def test_render(self): s = cStringIO.StringIO() - r = language.parse_request({}, "GET:'/foo'") + r = language.parse_request("GET:'/foo'") assert language.serve(r, s, {}, "foo.com") def test_multiline(self): @@ -476,7 +470,7 @@ class TestRequest: "/foo" ir,@1 """ - r = language.parse_request({}, l) + r = language.parse_request(l) assert r.method.string() == "GET" assert r.path.string() == "/foo" assert r.actions @@ -493,24 +487,24 @@ class TestRequest: ir,@1 """ - r = language.parse_request({}, l) + r = language.parse_request(l) assert r.method.string() == "GET" assert r.path.string().endswith("bar") assert r.actions def test_spec(self): def rt(s): - s = language.parse_request({}, s).spec() - assert language.parse_request({}, s).spec() == s + s = language.parse_request(s).spec() + assert language.parse_request(s).spec() == s rt("get:/foo") rt("get:/foo:da") def test_freeze(self): - r = language.parse_request({}, "GET:/:b@100").freeze({}) + r = language.parse_request("GET:/:b@100").freeze({}) assert len(r.spec()) > 100 def test_path_generator(self): - r = language.parse_request({}, "GET:@100").freeze({}) + r = language.parse_request("GET:@100").freeze({}) assert len(r.spec()) > 100 @@ -580,59 +574,53 @@ class TestWriteValues: def test_write_values_after(self): s = cStringIO.StringIO() - r = language.parse_response({}, "400:da") + r = language.parse_response("400:da") language.serve(r, s, {}) s = cStringIO.StringIO() - r = language.parse_response({}, "400:pa,0") + r = language.parse_response("400:pa,0") language.serve(r, s, {}) s = cStringIO.StringIO() - r = language.parse_response({}, "400:ia,'xx'") + r = language.parse_response("400:ia,'xx'") language.serve(r, s, {}) assert s.getvalue().endswith('xx') class TestResponse: def dummy_response(self): - return language.parse_response({}, "400'msg'") - - def test_file(self): - p = tutils.test_data.path("data") - d = dict(staticdir=p) - r = language.parse_response(d, "+response") - assert r.code.string() == "202" + return language.parse_response("400'msg'") def test_response(self): - r = language.parse_response({}, "400:m'msg'") + r = language.parse_response("400:m'msg'") assert r.code.string() == "400" assert r.reason.string() == "msg" - r = language.parse_response({}, "400:m'msg':b@100b") + r = language.parse_response("400:m'msg':b@100b") assert r.reason.string() == "msg" assert r.body.values({}) assert str(r) - r = language.parse_response({}, "200") + r = language.parse_response("200") assert r.code.string() == "200" assert not r.reason assert "OK" in [i[:] for i in r.preamble({})] def test_render(self): s = cStringIO.StringIO() - r = language.parse_response({}, "400:m'msg'") + r = language.parse_response("400:m'msg'") assert language.serve(r, s, {}) def test_raw(self): s = cStringIO.StringIO() - r = language.parse_response({}, "400:b'foo'") + r = language.parse_response("400:b'foo'") language.serve(r, s, {}) v = s.getvalue() assert "Content-Length" in v assert "Date" in v s = cStringIO.StringIO() - r = language.parse_response({}, "400:b'foo':r") + r = language.parse_response("400:b'foo':r") language.serve(r, s, {}) v = s.getvalue() assert not "Content-Length" in v @@ -643,9 +631,9 @@ class TestResponse: s = cStringIO.StringIO() language.serve(x, s, {}) assert x.length({}) == len(s.getvalue()) - testlen(language.parse_response({}, "400:m'msg':r")) - testlen(language.parse_response({}, "400:m'msg':h'foo'='bar':r")) - testlen(language.parse_response({}, "400:m'msg':h'foo'='bar':b@100b:r")) + testlen(language.parse_response("400:m'msg':r")) + testlen(language.parse_response("400:m'msg':h'foo'='bar':r")) + testlen(language.parse_response("400:m'msg':h'foo'='bar':b@100b:r")) def test_maximum_length(self): def testlen(x): @@ -654,59 +642,59 @@ class TestResponse: language.serve(x, s, {}) assert m >= len(s.getvalue()) - r = language.parse_response({}, "400:m'msg':b@100:d0") + r = language.parse_response("400:m'msg':b@100:d0") testlen(r) - r = language.parse_response({}, "400:m'msg':b@100:d0:i0,'foo'") + r = language.parse_response("400:m'msg':b@100:d0:i0,'foo'") testlen(r) - r = language.parse_response({}, "400:m'msg':b@100:d0:i0,'foo'") + r = language.parse_response("400:m'msg':b@100:d0:i0,'foo'") testlen(r) def test_render(self): - r = language.parse_response({}, "400:p0,100:dr") + r = language.parse_response("400:p0,100:dr") assert "p0" in r.spec() s = r.preview_safe() assert not "p0" in s.spec() def test_parse_err(self): - tutils.raises(language.ParseException, language.parse_response, {}, "400:msg,b:") + tutils.raises(language.ParseException, language.parse_response, "400:msg,b:") try: - language.parse_response({}, "400'msg':b:") + language.parse_response("400'msg':b:") except language.ParseException, v: assert v.marked() assert str(v) def test_nonascii(self): - tutils.raises("ascii", language.parse_response, {}, "foo:b\xf0") + tutils.raises("ascii", language.parse_response, "foo:b\xf0") def test_parse_header(self): - r = language.parse_response({}, '400:h"foo"="bar"') + r = language.parse_response('400:h"foo"="bar"') assert utils.get_header("foo", r.headers) def test_parse_pause_before(self): - r = language.parse_response({}, "400:p0,10") + r = language.parse_response("400:p0,10") assert r.actions[0].spec() == "p0,10" def test_parse_pause_after(self): - r = language.parse_response({}, "400:pa,10") + r = language.parse_response("400:pa,10") assert r.actions[0].spec() == "pa,10" def test_parse_pause_random(self): - r = language.parse_response({}, "400:pr,10") + r = language.parse_response("400:pr,10") assert r.actions[0].spec() == "pr,10" def test_parse_stress(self): # While larger values are known to work on linux, # len() technically returns an int and a python 2.7 int on windows has 32bit precision. # Therefore, we should keep the body length < 2147483647 bytes in our tests. - r = language.parse_response({}, "400:b@1g") + r = language.parse_response("400:b@1g") assert r.length({}) def test_spec(self): def rt(s): - s = language.parse_response({}, s).spec() - assert language.parse_response({}, s).spec() == s + s = language.parse_response(s).spec() + assert language.parse_response(s).spec() == s rt("400:b@100g") rt("400") rt("400:da") -- cgit v1.2.3 From d6ee5327112182202513ff6ce62d95df1567fdb6 Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Sat, 25 Oct 2014 14:24:05 +1300 Subject: Whitespace and formatting --- test/test_language.py | 45 +++++++++++++++++++++++++++++---------------- 1 file changed, 29 insertions(+), 16 deletions(-) (limited to 'test/test_language.py') diff --git a/test/test_language.py b/test/test_language.py index 73b4583f..18c68caa 100644 --- a/test/test_language.py +++ b/test/test_language.py @@ -1,4 +1,5 @@ -import os, cStringIO +import os +import cStringIO from libpathod import language, utils import tutils @@ -475,7 +476,6 @@ class TestRequest: assert r.path.string() == "/foo" assert r.actions - l = """ GET @@ -611,6 +611,11 @@ class TestResponse: r = language.parse_response("400:m'msg'") assert language.serve(r, s, {}) + r = language.parse_response("400:p0,100:dr") + assert "p0" in r.spec() + s = r.preview_safe() + assert "p0" not in s.spec() + def test_raw(self): s = cStringIO.StringIO() r = language.parse_response("400:b'foo'") @@ -651,12 +656,6 @@ class TestResponse: r = language.parse_response("400:m'msg':b@100:d0:i0,'foo'") testlen(r) - def test_render(self): - r = language.parse_response("400:p0,100:dr") - assert "p0" in r.spec() - s = r.preview_safe() - assert not "p0" in s.spec() - def test_parse_err(self): tutils.raises(language.ParseException, language.parse_response, "400:msg,b:") try: @@ -685,9 +684,10 @@ class TestResponse: assert r.actions[0].spec() == "pr,10" def test_parse_stress(self): - # While larger values are known to work on linux, - # len() technically returns an int and a python 2.7 int on windows has 32bit precision. - # Therefore, we should keep the body length < 2147483647 bytes in our tests. + # While larger values are known to work on linux, len() technically + # returns an int and a python 2.7 int on windows has 32bit precision. + # Therefore, we should keep the body length < 2147483647 bytes in our + # tests. r = language.parse_response("400:b@1g") assert r.length({}) @@ -700,16 +700,29 @@ class TestResponse: rt("400:da") - def test_read_file(): tutils.raises(language.FileAccessDenied, language.read_file, {}, "=/foo") p = tutils.test_data.path("data") d = dict(staticdir=p) assert language.read_file(d, "+./file").strip() == "testfile" assert language.read_file(d, "+file").strip() == "testfile" - tutils.raises(language.FileAccessDenied, language.read_file, d, "+./nonexistent") - tutils.raises(language.FileAccessDenied, language.read_file, d, "+/nonexistent") - - tutils.raises(language.FileAccessDenied, language.read_file, d, "+../test_language.py") + tutils.raises( + language.FileAccessDenied, + language.read_file, + d, + "+./nonexistent" + ) + tutils.raises( + language.FileAccessDenied, + language.read_file, + d, + "+/nonexistent" + ) + tutils.raises( + language.FileAccessDenied, + language.read_file, + d, + "+../test_language.py" + ) d["unconstrained_file_access"] = True assert language.read_file(d, "+../test_language.py") -- cgit v1.2.3 From 6d8431ab3e96568b3579a85e680371fd20c961aa Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Sat, 25 Oct 2014 16:20:23 +1300 Subject: Allow specification of multiple patterns from file and on command line --- test/test_language.py | 60 ++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 45 insertions(+), 15 deletions(-) (limited to 'test/test_language.py') diff --git a/test/test_language.py b/test/test_language.py index 18c68caa..007eb5b7 100644 --- a/test/test_language.py +++ b/test/test_language.py @@ -6,6 +6,10 @@ import tutils language.TESTING = True +def parse_request(s): + return language.parse_requests(s)[0] + + class TestValueNakedLiteral: def test_expr(self): v = language.ValueNakedLiteral("foo") @@ -302,8 +306,8 @@ class TestHeaders: assert language.parse_response("400:c'foo'").headers[0].key.val == "Content-Type" assert language.parse_response("400:l'foo'").headers[0].key.val == "Location" - assert 'Android' in language.parse_request("get:/:ua").headers[0].value.val - assert language.parse_request("get:/:ua").headers[0].key.val == "User-Agent" + assert 'Android' in parse_request("get:/:ua").headers[0].value.val + assert parse_request("get:/:ua").headers[0].key.val == "User-Agent" class TestShortcutUserAgent: @@ -337,7 +341,7 @@ class Test_Action: assert l[0].offset == 0 def test_resolve(self): - r = language.parse_request('GET:"/foo"') + r = parse_request('GET:"/foo"') e = language.DisconnectAt("r") ret = e.resolve(r, {}) assert isinstance(ret.offset, int) @@ -446,23 +450,49 @@ class TestPauses: class TestRequest: def test_nonascii(self): - tutils.raises("ascii", language.parse_request, "get:\xf0") + tutils.raises("ascii", parse_request, "get:\xf0") def test_err(self): - tutils.raises(language.ParseException, language.parse_request, 'GET') + tutils.raises(language.ParseException, parse_request, 'GET') def test_simple(self): - r = language.parse_request('GET:"/foo"') + r = parse_request('GET:"/foo"') assert r.method.string() == "GET" assert r.path.string() == "/foo" - r = language.parse_request('GET:/foo') + r = parse_request('GET:/foo') assert r.path.string() == "/foo" - r = language.parse_request('GET:@1k') + r = parse_request('GET:@1k') assert len(r.path.string()) == 1024 + def test_multi(self): + r = language.parse_requests("GET:/ PUT:/") + assert r[0].method.string() == "GET" + assert r[1].method.string() == "PUT" + assert len(r) == 2 + + l = """ + GET + "/foo" + ir,@1 + + PUT + + "/foo + + + + bar" + + ir,@1 + """ + r = language.parse_requests(l) + assert len(r) == 2 + assert r[0].method.string() == "GET" + assert r[1].method.string() == "PUT" + def test_render(self): s = cStringIO.StringIO() - r = language.parse_request("GET:'/foo'") + r = parse_request("GET:'/foo'") assert language.serve(r, s, {}, "foo.com") def test_multiline(self): @@ -471,7 +501,7 @@ class TestRequest: "/foo" ir,@1 """ - r = language.parse_request(l) + r = parse_request(l) assert r.method.string() == "GET" assert r.path.string() == "/foo" assert r.actions @@ -487,24 +517,24 @@ class TestRequest: ir,@1 """ - r = language.parse_request(l) + r = parse_request(l) assert r.method.string() == "GET" assert r.path.string().endswith("bar") assert r.actions def test_spec(self): def rt(s): - s = language.parse_request(s).spec() - assert language.parse_request(s).spec() == s + s = parse_request(s).spec() + assert parse_request(s).spec() == s rt("get:/foo") rt("get:/foo:da") def test_freeze(self): - r = language.parse_request("GET:/:b@100").freeze({}) + r = parse_request("GET:/:b@100").freeze({}) assert len(r.spec()) > 100 def test_path_generator(self): - r = language.parse_request("GET:@100").freeze({}) + r = parse_request("GET:@100").freeze({}) assert len(r.spec()) > 100 -- cgit v1.2.3 From 609d6eab30aac0601106993eb8c5d9a953ba402b Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Sat, 25 Oct 2014 17:27:08 +1300 Subject: Make grammar less ambiguous for multi-pattern files --- test/test_language.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) (limited to 'test/test_language.py') diff --git a/test/test_language.py b/test/test_language.py index 007eb5b7..b2add149 100644 --- a/test/test_language.py +++ b/test/test_language.py @@ -464,7 +464,7 @@ class TestRequest: r = parse_request('GET:@1k') assert len(r.path.string()) == 1024 - def test_multi(self): + def test_multiple(self): r = language.parse_requests("GET:/ PUT:/") assert r[0].method.string() == "GET" assert r[1].method.string() == "PUT" @@ -490,6 +490,15 @@ class TestRequest: assert r[0].method.string() == "GET" assert r[1].method.string() == "PUT" + l = """ + get:"http://localhost:9999/p/200":ir,@1 + get:"http://localhost:9999/p/200":ir,@2 + """ + r = language.parse_requests(l) + assert len(r) == 2 + assert r[0].method.string() == "GET" + assert r[1].method.string() == "GET" + def test_render(self): s = cStringIO.StringIO() r = parse_request("GET:'/foo'") -- cgit v1.2.3 From fc4f9a1c7a0734a190b99265ca50d72014173859 Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Sat, 25 Oct 2014 17:58:59 +1300 Subject: pathoc -n 0 repeats forever --- test/test_language.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'test/test_language.py') diff --git a/test/test_language.py b/test/test_language.py index b2add149..0818c587 100644 --- a/test/test_language.py +++ b/test/test_language.py @@ -696,7 +696,9 @@ class TestResponse: testlen(r) def test_parse_err(self): - tutils.raises(language.ParseException, language.parse_response, "400:msg,b:") + tutils.raises( + language.ParseException, language.parse_response, "400:msg,b:" + ) try: language.parse_response("400'msg':b:") except language.ParseException, v: -- cgit v1.2.3 From fc1fc80469dca11ff0241c4b263e4b39e5506ddd Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Sun, 26 Oct 2014 10:50:32 +1300 Subject: Allow nesting of pathod response specs in pathoc specs This opens the door to really neat, repeatable, client-side driven fuzzing, especially of proxies. --- test/test_language.py | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) (limited to 'test/test_language.py') diff --git a/test/test_language.py b/test/test_language.py index 0818c587..f3cfa5a9 100644 --- a/test/test_language.py +++ b/test/test_language.py @@ -223,6 +223,29 @@ class TestMisc: s = v.spec() assert s == e.parseString(s)[0].spec() + def test_pathodspec(self): + e = language.PathodSpec.expr() + v = e.parseString("s'200'")[0] + assert v.value.val == "200" + tutils.raises( + language.ParseException, + e.parseString, + "s'foo'" + ) + + v = e.parseString('s"200:b@1"')[0] + assert "@1" in v.spec() + f = v.freeze({}) + assert "@1" not in f.spec() + + r = parse_request('GET:"/foo":s"200"') + assert "200" in r.preamble({}) + + f = r.freeze({}) + assert parse_request(f.spec()) + + + def test_code(self): e = language.Code.expr() v = e.parseString("200")[0] @@ -661,14 +684,12 @@ class TestResponse: language.serve(r, s, {}) v = s.getvalue() assert "Content-Length" in v - assert "Date" in v s = cStringIO.StringIO() r = language.parse_response("400:b'foo':r") language.serve(r, s, {}) v = s.getvalue() assert not "Content-Length" in v - assert not "Date" in v def test_length(self): def testlen(x): -- cgit v1.2.3 From 974bd9d0f9f3d231ff99496c55ae40355398cfc6 Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Sun, 26 Oct 2014 12:56:28 +1300 Subject: Resolve a quoting ambiguity in nested response specs --- test/test_language.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) (limited to 'test/test_language.py') diff --git a/test/test_language.py b/test/test_language.py index f3cfa5a9..d8392404 100644 --- a/test/test_language.py +++ b/test/test_language.py @@ -36,10 +36,13 @@ class TestValueLiteral: def test_spec(self): v = language.ValueLiteral("foo") - assert v.spec() == r'"foo"' + assert v.spec() == r"'foo'" v = language.ValueLiteral("f\x00oo") - assert v.spec() == repr(v) == r'"f\x00oo"' + assert v.spec() == repr(v) == r"'f\x00oo'" + + v = language.ValueLiteral("\"") + assert v.spec() == repr(v) == '\'"\'' def test_freeze(self): v = language.ValueLiteral("foo") @@ -186,7 +189,7 @@ class TestMisc: assert e.parseString("'get'")[0].value.val == "get" assert e.parseString("get")[0].spec() == "get" - assert e.parseString("'foo'")[0].spec() == '"foo"' + assert e.parseString("'foo'")[0].spec() == "'foo'" s = e.parseString("get")[0].spec() assert s == e.parseString(s)[0].spec() @@ -238,13 +241,14 @@ class TestMisc: f = v.freeze({}) assert "@1" not in f.spec() - r = parse_request('GET:"/foo":s"200"') - assert "200" in r.preamble({}) - - f = r.freeze({}) - assert parse_request(f.spec()) - + def test_pathodspec_freeze(self): + spec = r'GET:"/foo":s"200:ir,\'\"\'"' + r = parse_request(spec) + assert r.freeze({}) + spec = r'GET:"/foo":s"200:ir,\"\'\""' + r = parse_request(spec) + assert r.freeze({}) def test_code(self): e = language.Code.expr() -- cgit v1.2.3 From bd1f7ebb5c3cf3dfa613e194f4728bae1420b241 Mon Sep 17 00:00:00 2001 From: Aldo Cortesi Date: Sun, 26 Oct 2014 16:27:25 +1300 Subject: Improve netability of grammars --- test/test_language.py | 38 +++++++++++++++++++++++++++----------- 1 file changed, 27 insertions(+), 11 deletions(-) (limited to 'test/test_language.py') diff --git a/test/test_language.py b/test/test_language.py index d8392404..e2d5190f 100644 --- a/test/test_language.py +++ b/test/test_language.py @@ -6,6 +6,10 @@ import tutils language.TESTING = True +def test_quote(): + assert language.quote("'\\\\'") + + def parse_request(s): return language.parse_requests(s)[0] @@ -29,7 +33,7 @@ class TestValueLiteral: assert v.expr() assert v.val == "foo" - v = language.ValueLiteral(r"foo\n") + v = language.ValueLiteral("foo\n") assert v.expr() assert v.val == "foo\n" assert repr(v) @@ -44,9 +48,20 @@ class TestValueLiteral: v = language.ValueLiteral("\"") assert v.spec() == repr(v) == '\'"\'' - def test_freeze(self): - v = language.ValueLiteral("foo") - assert v.freeze({}).val == v.val + def roundtrip(self, spec): + e = language.ValueLiteral.expr() + v = language.ValueLiteral(spec) + v2 = e.parseString(v.spec()) + assert v.val == v2[0].val + assert v.spec() == v2[0].spec() + + def test_roundtrip(self): + self.roundtrip("'") + self.roundtrip('\'') + self.roundtrip("a") + self.roundtrip("\"") + self.roundtrip(r"\\") + self.roundtrip("200:b'foo':i23,'\\''") class TestValueGenerate: @@ -242,13 +257,14 @@ class TestMisc: assert "@1" not in f.spec() def test_pathodspec_freeze(self): - spec = r'GET:"/foo":s"200:ir,\'\"\'"' - r = parse_request(spec) - assert r.freeze({}) - - spec = r'GET:"/foo":s"200:ir,\"\'\""' - r = parse_request(spec) - assert r.freeze({}) + e = language.PathodSpec( + language.ValueLiteral( + "200:b'foo':i10,'\\''".encode( + "string_escape" + ) + ) + ) + assert e.freeze({}) def test_code(self): e = language.Code.expr() -- cgit v1.2.3