|
import pytest |
|
|
|
import aiohttp |
|
from aiohttp import content_disposition_filename, parse_content_disposition |
|
|
|
|
|
class TestParseContentDisposition: |
|
|
|
|
|
def test_parse_empty(self) -> None: |
|
disptype, params = parse_content_disposition(None) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_inlonly(self) -> None: |
|
disptype, params = parse_content_disposition("inline") |
|
assert "inline" == disptype |
|
assert {} == params |
|
|
|
def test_inlonlyquoted(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition('"inline"') |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_semicolon(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'form-data; name="data"; filename="file ; name.mp4"' |
|
) |
|
assert disptype == "form-data" |
|
assert params == {"name": "data", "filename": "file ; name.mp4"} |
|
|
|
def test_inlwithasciifilename(self) -> None: |
|
disptype, params = parse_content_disposition('inline; filename="foo.html"') |
|
assert "inline" == disptype |
|
assert {"filename": "foo.html"} == params |
|
|
|
def test_inlwithfnattach(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'inline; filename="Not an attachment!"' |
|
) |
|
assert "inline" == disptype |
|
assert {"filename": "Not an attachment!"} == params |
|
|
|
def test_attonly(self) -> None: |
|
disptype, params = parse_content_disposition("attachment") |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
def test_attonlyquoted(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition('"attachment"') |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attonlyucase(self) -> None: |
|
disptype, params = parse_content_disposition("ATTACHMENT") |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
def test_attwithasciifilename(self) -> None: |
|
disptype, params = parse_content_disposition('attachment; filename="foo.html"') |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html"} == params |
|
|
|
def test_inlwithasciifilenamepdf(self) -> None: |
|
disptype, params = parse_content_disposition('attachment; filename="foo.pdf"') |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.pdf"} == params |
|
|
|
def test_attwithasciifilename25(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="0000000000111111111122222"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "0000000000111111111122222"} == params |
|
|
|
def test_attwithasciifilename35(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="00000000001111111111222222222233333"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "00000000001111111111222222222233333"} == params |
|
|
|
def test_attwithasciifnescapedchar(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
r'attachment; filename="f\oo.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html"} == params |
|
|
|
def test_attwithasciifnescapedquote(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename=""quoting" tested.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": '"quoting" tested.html'} == params |
|
|
|
@pytest.mark.skip("need more smart parser which respects quoted text") |
|
def test_attwithquotedsemicolon(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="Here\'s a semicolon;.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "Here's a semicolon;.html"} == params |
|
|
|
def test_attwithfilenameandextparam(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; foo="bar"; filename="foo.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html", "foo": "bar"} == params |
|
|
|
def test_attwithfilenameandextparamescaped(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; foo=""\\";filename="foo.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html", "foo": '"\\'} == params |
|
|
|
def test_attwithasciifilenameucase(self) -> None: |
|
disptype, params = parse_content_disposition('attachment; FILENAME="foo.html"') |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html"} == params |
|
|
|
def test_attwithasciifilenamenq(self) -> None: |
|
disptype, params = parse_content_disposition("attachment; filename=foo.html") |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html"} == params |
|
|
|
def test_attwithtokfncommanq(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename=foo,bar.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attwithasciifilenamenqs(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename=foo.html ;" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attemptyparam(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition("attachment; ;filename=foo") |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attwithasciifilenamenqws(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename=foo bar.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attwithfntokensq(self) -> None: |
|
disptype, params = parse_content_disposition("attachment; filename='foo.html'") |
|
assert "attachment" == disptype |
|
assert {"filename": "'foo.html'"} == params |
|
|
|
def test_attwithisofnplain(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="foo-ä.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo-ä.html"} == params |
|
|
|
def test_attwithutf8fnplain(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="foo-ä.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo-ä.html"} == params |
|
|
|
def test_attwithfnrawpctenca(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="foo-%41.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo-%41.html"} == params |
|
|
|
def test_attwithfnusingpct(self) -> None: |
|
disptype, params = parse_content_disposition('attachment; filename="50%.html"') |
|
assert "attachment" == disptype |
|
assert {"filename": "50%.html"} == params |
|
|
|
def test_attwithfnrawpctencaq(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
r'attachment; filename="foo-%\41.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": r"foo-%41.html"} == params |
|
|
|
def test_attwithnamepct(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="foo-%41.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo-%41.html"} == params |
|
|
|
def test_attwithfilenamepctandiso(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="ä-%41.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "ä-%41.html"} == params |
|
|
|
def test_attwithfnrawpctenclong(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="foo-%c3%a4-%e2%82%ac.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo-%c3%a4-%e2%82%ac.html"} == params |
|
|
|
def test_attwithasciifilenamews1(self) -> None: |
|
disptype, params = parse_content_disposition('attachment; filename ="foo.html"') |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html"} == params |
|
|
|
def test_attwith2filenames(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="foo.html"; filename="bar.html"' |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attfnbrokentoken(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename=foo[1](2).html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attfnbrokentokeniso(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename=foo-ä.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attfnbrokentokenutf(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename=foo-ä.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attmissingdisposition(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition("filename=foo.html") |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attmissingdisposition2(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition("x=y; filename=foo.html") |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attmissingdisposition3(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
'"foo; filename=bar;baz"; filename=qux' |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attmissingdisposition4(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"filename=foo.html, filename=bar.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_emptydisposition(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition("; filename=foo.html") |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_doublecolon(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
": inline; attachment; filename=foo.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attandinline(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"inline; attachment; filename=foo.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attandinline2(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; inline; filename=foo.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attbrokenquotedfn(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="foo.html".txt' |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attbrokenquotedfn2(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition('attachment; filename="bar') |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attbrokenquotedfn3(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename=foo"bar;baz"qux' |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attmultinstances(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename=foo.html, attachment; filename=bar.html" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attmissingdelim(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; foo=foo filename=bar" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attmissingdelim2(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename=bar foo=foo" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attmissingdelim3(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition("attachment filename=bar") |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attreversed(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"filename=foo.html; attachment" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attconfusedparam(self) -> None: |
|
disptype, params = parse_content_disposition("attachment; xfilename=foo.html") |
|
assert "attachment" == disptype |
|
assert {"xfilename": "foo.html"} == params |
|
|
|
def test_attabspath(self) -> None: |
|
disptype, params = parse_content_disposition('attachment; filename="/foo.html"') |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html"} == params |
|
|
|
def test_attabspathwin(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="\\foo.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo.html"} == params |
|
|
|
def test_attcdate(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; creation-date="Wed, 12 Feb 1997 16:29:51 -0500"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"creation-date": "Wed, 12 Feb 1997 16:29:51 -0500"} == params |
|
|
|
def test_attmdate(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; modification-date="Wed, 12 Feb 1997 16:29:51 -0500"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"modification-date": "Wed, 12 Feb 1997 16:29:51 -0500"} == params |
|
|
|
def test_dispext(self) -> None: |
|
disptype, params = parse_content_disposition("foobar") |
|
assert "foobar" == disptype |
|
assert {} == params |
|
|
|
def test_dispextbadfn(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; example="filename=example.txt"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"example": "filename=example.txt"} == params |
|
|
|
def test_attwithisofn2231iso(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=iso-8859-1''foo-%E4.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*": "foo-ä.html"} == params |
|
|
|
def test_attwithfn2231utf8(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=UTF-8''foo-%c3%a4-%e2%82%ac.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*": "foo-ä-€.html"} == params |
|
|
|
def test_attwithfn2231noc(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=''foo-%c3%a4-%e2%82%ac.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*": "foo-ä-€.html"} == params |
|
|
|
def test_attwithfn2231utf8comp(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=UTF-8''foo-a%cc%88.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*": "foo-ä.html"} == params |
|
|
|
@pytest.mark.skip("should raise decoding error: %82 is invalid for latin1") |
|
def test_attwithfn2231utf8_bad(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=iso-8859-1''foo-%c3%a4-%e2%82%ac.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
@pytest.mark.skip("should raise decoding error: %E4 is invalid for utf-8") |
|
def test_attwithfn2231iso_bad(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=utf-8''foo-%E4.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
def test_attwithfn2231ws1(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename *=UTF-8''foo-%c3%a4.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
def test_attwithfn2231ws2(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*= UTF-8''foo-%c3%a4.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*": "foo-ä.html"} == params |
|
|
|
def test_attwithfn2231ws3(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename* =UTF-8''foo-%c3%a4.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*": "foo-ä.html"} == params |
|
|
|
def test_attwithfn2231quot(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=\"UTF-8''foo-%c3%a4.html\"" |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
def test_attwithfn2231quot2(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename*="foo%20bar.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
def test_attwithfn2231singleqmissing(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=UTF-8'foo-%c3%a4.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
@pytest.mark.skip("urllib.parse.unquote is tolerate to standalone % chars") |
|
def test_attwithfn2231nbadpct1(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=UTF-8''foo%" |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
@pytest.mark.skip("urllib.parse.unquote is tolerate to standalone % chars") |
|
def test_attwithfn2231nbadpct2(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=UTF-8''f%oo.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
def test_attwithfn2231dpct(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=UTF-8''A-%2541.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*": "A-%41.html"} == params |
|
|
|
def test_attwithfn2231abspathdisguised(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=UTF-8''%5cfoo.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*": "\\foo.html"} == params |
|
|
|
def test_attfncont(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename*0="foo."; filename*1="html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*0": "foo.", "filename*1": "html"} == params |
|
|
|
def test_attfncontqs(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
r'attachment; filename*0="foo"; filename*1="\b\a\r.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*0": "foo", "filename*1": "bar.html"} == params |
|
|
|
def test_attfncontenc(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*0*=UTF-8" 'foo-%c3%a4; filename*1=".html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*0*": "UTF-8" "foo-%c3%a4", "filename*1": ".html"} == params |
|
|
|
def test_attfncontlz(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename*0="foo"; filename*01="bar"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*0": "foo", "filename*01": "bar"} == params |
|
|
|
def test_attfncontnc(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename*0="foo"; filename*2="bar"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*0": "foo", "filename*2": "bar"} == params |
|
|
|
def test_attfnconts1(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename*0="foo."; filename*2="html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*0": "foo.", "filename*2": "html"} == params |
|
|
|
def test_attfncontord(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename*1="bar"; filename*0="foo"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename*0": "foo", "filename*1": "bar"} == params |
|
|
|
def test_attfnboth(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="foo-ae.html";' " filename*=UTF-8''foo-%c3%a4.html" |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo-ae.html", "filename*": "foo-ä.html"} == params |
|
|
|
def test_attfnboth2(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*=UTF-8''foo-%c3%a4.html;" ' filename="foo-ae.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "foo-ae.html", "filename*": "foo-ä.html"} == params |
|
|
|
def test_attfnboth3(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*0*=ISO-8859-15''euro-sign%3d%a4;" |
|
" filename*=ISO-8859-1''currency-sign%3d%a4" |
|
) |
|
assert "attachment" == disptype |
|
assert { |
|
"filename*": "currency-sign=¤", |
|
"filename*0*": "ISO-8859-15''euro-sign%3d%a4", |
|
} == params |
|
|
|
def test_attnewandfn(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; foobar=x; filename="foo.html"' |
|
) |
|
assert "attachment" == disptype |
|
assert {"foobar": "x", "filename": "foo.html"} == params |
|
|
|
def test_attrfc2047token(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionHeader): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename==?ISO-8859-1?Q?foo-=E4.html?=" |
|
) |
|
assert disptype is None |
|
assert {} == params |
|
|
|
def test_attrfc2047quoted(self) -> None: |
|
disptype, params = parse_content_disposition( |
|
'attachment; filename="=?ISO-8859-1?Q?foo-=E4.html?="' |
|
) |
|
assert "attachment" == disptype |
|
assert {"filename": "=?ISO-8859-1?Q?foo-=E4.html?="} == params |
|
|
|
def test_bad_continuous_param(self) -> None: |
|
with pytest.warns(aiohttp.BadContentDispositionParam): |
|
disptype, params = parse_content_disposition( |
|
"attachment; filename*0=foo bar" |
|
) |
|
assert "attachment" == disptype |
|
assert {} == params |
|
|
|
|
|
class TestContentDispositionFilename: |
|
|
|
|
|
def test_no_filename(self) -> None: |
|
assert content_disposition_filename({}) is None |
|
assert content_disposition_filename({"foo": "bar"}) is None |
|
|
|
def test_filename(self) -> None: |
|
params = {"filename": "foo.html"} |
|
assert "foo.html" == content_disposition_filename(params) |
|
|
|
def test_filename_ext(self) -> None: |
|
params = {"filename*": "файл.html"} |
|
assert "файл.html" == content_disposition_filename(params) |
|
|
|
def test_attfncont(self) -> None: |
|
params = {"filename*0": "foo.", "filename*1": "html"} |
|
assert "foo.html" == content_disposition_filename(params) |
|
|
|
def test_attfncontqs(self) -> None: |
|
params = {"filename*0": "foo", "filename*1": "bar.html"} |
|
assert "foobar.html" == content_disposition_filename(params) |
|
|
|
def test_attfncontenc(self) -> None: |
|
params = {"filename*0*": "UTF-8''foo-%c3%a4", "filename*1": ".html"} |
|
assert "foo-ä.html" == content_disposition_filename(params) |
|
|
|
def test_attfncontlz(self) -> None: |
|
params = {"filename*0": "foo", "filename*01": "bar"} |
|
assert "foo" == content_disposition_filename(params) |
|
|
|
def test_attfncontnc(self) -> None: |
|
params = {"filename*0": "foo", "filename*2": "bar"} |
|
assert "foo" == content_disposition_filename(params) |
|
|
|
def test_attfnconts1(self) -> None: |
|
params = {"filename*1": "foo", "filename*2": "bar"} |
|
assert content_disposition_filename(params) is None |
|
|
|
def test_attfnboth(self) -> None: |
|
params = {"filename": "foo-ae.html", "filename*": "foo-ä.html"} |
|
assert "foo-ä.html" == content_disposition_filename(params) |
|
|
|
def test_attfnboth3(self) -> None: |
|
params = { |
|
"filename*0*": "ISO-8859-15''euro-sign%3d%a4", |
|
"filename*": "currency-sign=¤", |
|
} |
|
assert "currency-sign=¤" == content_disposition_filename(params) |
|
|
|
def test_attrfc2047quoted(self) -> None: |
|
params = {"filename": "=?ISO-8859-1?Q?foo-=E4.html?="} |
|
assert "=?ISO-8859-1?Q?foo-=E4.html?=" == content_disposition_filename(params) |
|
|
