123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064 |
- // Copyright 2009 The Go Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style
- // license that can be found in the LICENSE file.
- package url
- import (
- "bytes"
- encodingPkg "encoding"
- "encoding/gob"
- "encoding/json"
- "fmt"
- "io"
- "net"
- "reflect"
- "strings"
- "testing"
- )
- type URLTest struct {
- in string
- out *URL // expected parse
- roundtrip string // expected result of reserializing the URL; empty means same as "in".
- }
- var urltests = []URLTest{
- // no path
- {
- "http://www.google.com",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- },
- "",
- },
- // path
- {
- "http://www.google.com/",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- },
- "",
- },
- // path with hex escaping
- {
- "http://www.google.com/file%20one%26two",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/file one&two",
- RawPath: "/file%20one%26two",
- },
- "",
- },
- // fragment with hex escaping
- {
- "http://www.google.com/#file%20one%26two",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- Fragment: "file one&two",
- RawFragment: "file%20one%26two",
- },
- "",
- },
- // user
- {
- "ftp://webmaster@www.google.com/",
- &URL{
- Scheme: "ftp",
- User: User("webmaster"),
- Host: "www.google.com",
- Path: "/",
- },
- "",
- },
- // escape sequence in username
- {
- "ftp://john%20doe@www.google.com/",
- &URL{
- Scheme: "ftp",
- User: User("john doe"),
- Host: "www.google.com",
- Path: "/",
- },
- "ftp://john%20doe@www.google.com/",
- },
- // empty query
- {
- "http://www.google.com/?",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- ForceQuery: true,
- },
- "",
- },
- // query ending in question mark (Issue 14573)
- {
- "http://www.google.com/?foo=bar?",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- RawQuery: "foo=bar?",
- },
- "",
- },
- // query
- {
- "http://www.google.com/?q=go+language",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- RawQuery: "q=go+language",
- },
- "",
- },
- // query with hex escaping: NOT parsed
- {
- "http://www.google.com/?q=go%20language",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- RawQuery: "q=go%20language",
- },
- "",
- },
- // %20 outside query
- {
- "http://www.google.com/a%20b?q=c+d",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/a b",
- RawQuery: "q=c+d",
- },
- "",
- },
- // path without leading /, so no parsing
- {
- "http:www.google.com/?q=go+language",
- &URL{
- Scheme: "http",
- Opaque: "www.google.com/",
- RawQuery: "q=go+language",
- },
- "http:www.google.com/?q=go+language",
- },
- // path without leading /, so no parsing
- {
- "http:%2f%2fwww.google.com/?q=go+language",
- &URL{
- Scheme: "http",
- Opaque: "%2f%2fwww.google.com/",
- RawQuery: "q=go+language",
- },
- "http:%2f%2fwww.google.com/?q=go+language",
- },
- // non-authority with path
- {
- "mailto:/webmaster@golang.org",
- &URL{
- Scheme: "mailto",
- Path: "/webmaster@golang.org",
- },
- "mailto:///webmaster@golang.org", // unfortunate compromise
- },
- // non-authority
- {
- "mailto:webmaster@golang.org",
- &URL{
- Scheme: "mailto",
- Opaque: "webmaster@golang.org",
- },
- "",
- },
- // unescaped :// in query should not create a scheme
- {
- "/foo?query=http://bad",
- &URL{
- Path: "/foo",
- RawQuery: "query=http://bad",
- },
- "",
- },
- // leading // without scheme should create an authority
- {
- "//foo",
- &URL{
- Host: "foo",
- },
- "",
- },
- // leading // without scheme, with userinfo, path, and query
- {
- "//user@foo/path?a=b",
- &URL{
- User: User("user"),
- Host: "foo",
- Path: "/path",
- RawQuery: "a=b",
- },
- "",
- },
- // Three leading slashes isn't an authority, but doesn't return an error.
- // (We can't return an error, as this code is also used via
- // ServeHTTP -> ReadRequest -> Parse, which is arguably a
- // different URL parsing context, but currently shares the
- // same codepath)
- {
- "///threeslashes",
- &URL{
- Path: "///threeslashes",
- },
- "",
- },
- {
- "http://user:password@google.com",
- &URL{
- Scheme: "http",
- User: UserPassword("user", "password"),
- Host: "google.com",
- },
- "http://user:password@google.com",
- },
- // unescaped @ in username should not confuse host
- {
- "http://j@ne:password@google.com",
- &URL{
- Scheme: "http",
- User: UserPassword("j@ne", "password"),
- Host: "google.com",
- },
- "http://j%40ne:password@google.com",
- },
- // unescaped @ in password should not confuse host
- {
- "http://jane:p@ssword@google.com",
- &URL{
- Scheme: "http",
- User: UserPassword("jane", "p@ssword"),
- Host: "google.com",
- },
- "http://jane:p%40ssword@google.com",
- },
- {
- "http://j@ne:password@google.com/p@th?q=@go",
- &URL{
- Scheme: "http",
- User: UserPassword("j@ne", "password"),
- Host: "google.com",
- Path: "/p@th",
- RawQuery: "q=@go",
- },
- "http://j%40ne:password@google.com/p@th?q=@go",
- },
- {
- "http://www.google.com/?q=go+language#foo",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- RawQuery: "q=go+language",
- Fragment: "foo",
- },
- "",
- },
- {
- "http://www.google.com/?q=go+language#foo&bar",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- RawQuery: "q=go+language",
- Fragment: "foo&bar",
- },
- "http://www.google.com/?q=go+language#foo&bar",
- },
- {
- "http://www.google.com/?q=go+language#foo%26bar",
- &URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "/",
- RawQuery: "q=go+language",
- Fragment: "foo&bar",
- RawFragment: "foo%26bar",
- },
- "http://www.google.com/?q=go+language#foo%26bar",
- },
- {
- "file:///home/adg/rabbits",
- &URL{
- Scheme: "file",
- Host: "",
- Path: "/home/adg/rabbits",
- },
- "file:///home/adg/rabbits",
- },
- // "Windows" paths are no exception to the rule.
- // See golang.org/issue/6027, especially comment #9.
- {
- "file:///C:/FooBar/Baz.txt",
- &URL{
- Scheme: "file",
- Host: "",
- Path: "/C:/FooBar/Baz.txt",
- },
- "file:///C:/FooBar/Baz.txt",
- },
- // case-insensitive scheme
- {
- "MaIlTo:webmaster@golang.org",
- &URL{
- Scheme: "mailto",
- Opaque: "webmaster@golang.org",
- },
- "mailto:webmaster@golang.org",
- },
- // Relative path
- {
- "a/b/c",
- &URL{
- Path: "a/b/c",
- },
- "a/b/c",
- },
- // escaped '?' in username and password
- {
- "http://%3Fam:pa%3Fsword@google.com",
- &URL{
- Scheme: "http",
- User: UserPassword("?am", "pa?sword"),
- Host: "google.com",
- },
- "",
- },
- // host subcomponent; IPv4 address in RFC 3986
- {
- "http://192.168.0.1/",
- &URL{
- Scheme: "http",
- Host: "192.168.0.1",
- Path: "/",
- },
- "",
- },
- // host and port subcomponents; IPv4 address in RFC 3986
- {
- "http://192.168.0.1:8080/",
- &URL{
- Scheme: "http",
- Host: "192.168.0.1:8080",
- Path: "/",
- },
- "",
- },
- // host subcomponent; IPv6 address in RFC 3986
- {
- "http://[fe80::1]/",
- &URL{
- Scheme: "http",
- Host: "[fe80::1]",
- Path: "/",
- },
- "",
- },
- // host and port subcomponents; IPv6 address in RFC 3986
- {
- "http://[fe80::1]:8080/",
- &URL{
- Scheme: "http",
- Host: "[fe80::1]:8080",
- Path: "/",
- },
- "",
- },
- // host subcomponent; IPv6 address with zone identifier in RFC 6874
- {
- "http://[fe80::1%25en0]/", // alphanum zone identifier
- &URL{
- Scheme: "http",
- Host: "[fe80::1%en0]",
- Path: "/",
- },
- "",
- },
- // host and port subcomponents; IPv6 address with zone identifier in RFC 6874
- {
- "http://[fe80::1%25en0]:8080/", // alphanum zone identifier
- &URL{
- Scheme: "http",
- Host: "[fe80::1%en0]:8080",
- Path: "/",
- },
- "",
- },
- // host subcomponent; IPv6 address with zone identifier in RFC 6874
- {
- "http://[fe80::1%25%65%6e%301-._~]/", // percent-encoded+unreserved zone identifier
- &URL{
- Scheme: "http",
- Host: "[fe80::1%en01-._~]",
- Path: "/",
- },
- "http://[fe80::1%25en01-._~]/",
- },
- // host and port subcomponents; IPv6 address with zone identifier in RFC 6874
- {
- "http://[fe80::1%25%65%6e%301-._~]:8080/", // percent-encoded+unreserved zone identifier
- &URL{
- Scheme: "http",
- Host: "[fe80::1%en01-._~]:8080",
- Path: "/",
- },
- "http://[fe80::1%25en01-._~]:8080/",
- },
- // alternate escapings of path survive round trip
- {
- "http://rest.rsc.io/foo%2fbar/baz%2Fquux?alt=media",
- &URL{
- Scheme: "http",
- Host: "rest.rsc.io",
- Path: "/foo/bar/baz/quux",
- RawPath: "/foo%2fbar/baz%2Fquux",
- RawQuery: "alt=media",
- },
- "",
- },
- // issue 12036
- {
- "mysql://a,b,c/bar",
- &URL{
- Scheme: "mysql",
- Host: "a,b,c",
- Path: "/bar",
- },
- "",
- },
- // worst case host, still round trips
- {
- "scheme://!$&'()*+,;=hello!:1/path",
- &URL{
- Scheme: "scheme",
- Host: "!$&'()*+,;=hello!:1",
- Path: "/path",
- },
- "",
- },
- // worst case path, still round trips
- {
- "http://host/!$&'()*+,;=:@[hello]",
- &URL{
- Scheme: "http",
- Host: "host",
- Path: "/!$&'()*+,;=:@[hello]",
- RawPath: "/!$&'()*+,;=:@[hello]",
- },
- "",
- },
- // golang.org/issue/5684
- {
- "http://example.com/oid/[order_id]",
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "/oid/[order_id]",
- RawPath: "/oid/[order_id]",
- },
- "",
- },
- // golang.org/issue/12200 (colon with empty port)
- {
- "http://192.168.0.2:8080/foo",
- &URL{
- Scheme: "http",
- Host: "192.168.0.2:8080",
- Path: "/foo",
- },
- "",
- },
- {
- "http://192.168.0.2:/foo",
- &URL{
- Scheme: "http",
- Host: "192.168.0.2:",
- Path: "/foo",
- },
- "",
- },
- {
- // Malformed IPv6 but still accepted.
- "http://2b01:e34:ef40:7730:8e70:5aff:fefe:edac:8080/foo",
- &URL{
- Scheme: "http",
- Host: "2b01:e34:ef40:7730:8e70:5aff:fefe:edac:8080",
- Path: "/foo",
- },
- "",
- },
- {
- // Malformed IPv6 but still accepted.
- "http://2b01:e34:ef40:7730:8e70:5aff:fefe:edac:/foo",
- &URL{
- Scheme: "http",
- Host: "2b01:e34:ef40:7730:8e70:5aff:fefe:edac:",
- Path: "/foo",
- },
- "",
- },
- {
- "http://[2b01:e34:ef40:7730:8e70:5aff:fefe:edac]:8080/foo",
- &URL{
- Scheme: "http",
- Host: "[2b01:e34:ef40:7730:8e70:5aff:fefe:edac]:8080",
- Path: "/foo",
- },
- "",
- },
- {
- "http://[2b01:e34:ef40:7730:8e70:5aff:fefe:edac]:/foo",
- &URL{
- Scheme: "http",
- Host: "[2b01:e34:ef40:7730:8e70:5aff:fefe:edac]:",
- Path: "/foo",
- },
- "",
- },
- // golang.org/issue/7991 and golang.org/issue/12719 (non-ascii %-encoded in host)
- {
- "http://hello.世界.com/foo",
- &URL{
- Scheme: "http",
- Host: "hello.世界.com",
- Path: "/foo",
- },
- "http://hello.%E4%B8%96%E7%95%8C.com/foo",
- },
- {
- "http://hello.%e4%b8%96%e7%95%8c.com/foo",
- &URL{
- Scheme: "http",
- Host: "hello.世界.com",
- Path: "/foo",
- },
- "http://hello.%E4%B8%96%E7%95%8C.com/foo",
- },
- {
- "http://hello.%E4%B8%96%E7%95%8C.com/foo",
- &URL{
- Scheme: "http",
- Host: "hello.世界.com",
- Path: "/foo",
- },
- "",
- },
- // golang.org/issue/10433 (path beginning with //)
- {
- "http://example.com//foo",
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "//foo",
- },
- "",
- },
- // test that we can reparse the host names we accept.
- {
- "myscheme://authority<\"hi\">/foo",
- &URL{
- Scheme: "myscheme",
- Host: "authority<\"hi\">",
- Path: "/foo",
- },
- "",
- },
- // spaces in hosts are disallowed but escaped spaces in IPv6 scope IDs are grudgingly OK.
- // This happens on Windows.
- // golang.org/issue/14002
- {
- "tcp://[2020::2020:20:2020:2020%25Windows%20Loves%20Spaces]:2020",
- &URL{
- Scheme: "tcp",
- Host: "[2020::2020:20:2020:2020%Windows Loves Spaces]:2020",
- },
- "",
- },
- // test we can roundtrip magnet url
- // fix issue https://golang.org/issue/20054
- {
- "magnet:?xt=urn:btih:c12fe1c06bba254a9dc9f519b335aa7c1367a88a&dn",
- &URL{
- Scheme: "magnet",
- Host: "",
- Path: "",
- RawQuery: "xt=urn:btih:c12fe1c06bba254a9dc9f519b335aa7c1367a88a&dn",
- },
- "magnet:?xt=urn:btih:c12fe1c06bba254a9dc9f519b335aa7c1367a88a&dn",
- },
- {
- "mailto:?subject=hi",
- &URL{
- Scheme: "mailto",
- Host: "",
- Path: "",
- RawQuery: "subject=hi",
- },
- "mailto:?subject=hi",
- },
- }
- // more useful string for debugging than fmt's struct printer
- func ufmt(u *URL) string {
- var user, pass any
- if u.User != nil {
- user = u.User.Username()
- if p, ok := u.User.Password(); ok {
- pass = p
- }
- }
- return fmt.Sprintf("opaque=%q, scheme=%q, user=%#v, pass=%#v, host=%q, path=%q, rawpath=%q, rawq=%q, frag=%q, rawfrag=%q, forcequery=%v",
- u.Opaque, u.Scheme, user, pass, u.Host, u.Path, u.RawPath, u.RawQuery, u.Fragment, u.RawFragment, u.ForceQuery)
- }
- func BenchmarkString(b *testing.B) {
- b.StopTimer()
- b.ReportAllocs()
- for _, tt := range urltests {
- u, err := Parse(tt.in)
- if err != nil {
- b.Errorf("Parse(%q) returned error %s", tt.in, err)
- continue
- }
- if tt.roundtrip == "" {
- continue
- }
- b.StartTimer()
- var g string
- for i := 0; i < b.N; i++ {
- g = u.String()
- }
- b.StopTimer()
- if w := tt.roundtrip; b.N > 0 && g != w {
- b.Errorf("Parse(%q).String() == %q, want %q", tt.in, g, w)
- }
- }
- }
- func TestParse(t *testing.T) {
- for _, tt := range urltests {
- u, err := Parse(tt.in)
- if err != nil {
- t.Errorf("Parse(%q) returned error %v", tt.in, err)
- continue
- }
- if !reflect.DeepEqual(u, tt.out) {
- t.Errorf("Parse(%q):\n\tgot %v\n\twant %v\n", tt.in, ufmt(u), ufmt(tt.out))
- }
- }
- }
- const pathThatLooksSchemeRelative = "//not.a.user@not.a.host/just/a/path"
- var parseRequestURLTests = []struct {
- url string
- expectedValid bool
- }{
- {"http://foo.com", true},
- {"http://foo.com/", true},
- {"http://foo.com/path", true},
- {"/", true},
- {pathThatLooksSchemeRelative, true},
- {"//not.a.user@%66%6f%6f.com/just/a/path/also", true},
- {"*", true},
- {"http://192.168.0.1/", true},
- {"http://192.168.0.1:8080/", true},
- {"http://[fe80::1]/", true},
- {"http://[fe80::1]:8080/", true},
- // Tests exercising RFC 6874 compliance:
- {"http://[fe80::1%25en0]/", true}, // with alphanum zone identifier
- {"http://[fe80::1%25en0]:8080/", true}, // with alphanum zone identifier
- {"http://[fe80::1%25%65%6e%301-._~]/", true}, // with percent-encoded+unreserved zone identifier
- {"http://[fe80::1%25%65%6e%301-._~]:8080/", true}, // with percent-encoded+unreserved zone identifier
- {"foo.html", false},
- {"../dir/", false},
- {" http://foo.com", false},
- {"http://192.168.0.%31/", false},
- {"http://192.168.0.%31:8080/", false},
- {"http://[fe80::%31]/", false},
- {"http://[fe80::%31]:8080/", false},
- {"http://[fe80::%31%25en0]/", false},
- {"http://[fe80::%31%25en0]:8080/", false},
- // These two cases are valid as textual representations as
- // described in RFC 4007, but are not valid as address
- // literals with IPv6 zone identifiers in URIs as described in
- // RFC 6874.
- {"http://[fe80::1%en0]/", false},
- {"http://[fe80::1%en0]:8080/", false},
- }
- func TestParseRequestURI(t *testing.T) {
- for _, test := range parseRequestURLTests {
- _, err := ParseRequestURI(test.url)
- if test.expectedValid && err != nil {
- t.Errorf("ParseRequestURI(%q) gave err %v; want no error", test.url, err)
- } else if !test.expectedValid && err == nil {
- t.Errorf("ParseRequestURI(%q) gave nil error; want some error", test.url)
- }
- }
- url, err := ParseRequestURI(pathThatLooksSchemeRelative)
- if err != nil {
- t.Fatalf("Unexpected error %v", err)
- }
- if url.Path != pathThatLooksSchemeRelative {
- t.Errorf("ParseRequestURI path:\ngot %q\nwant %q", url.Path, pathThatLooksSchemeRelative)
- }
- }
- var stringURLTests = []struct {
- url URL
- want string
- }{
- // No leading slash on path should prepend slash on String() call
- {
- url: URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "search",
- },
- want: "http://www.google.com/search",
- },
- // Relative path with first element containing ":" should be prepended with "./", golang.org/issue/17184
- {
- url: URL{
- Path: "this:that",
- },
- want: "./this:that",
- },
- // Relative path with second element containing ":" should not be prepended with "./"
- {
- url: URL{
- Path: "here/this:that",
- },
- want: "here/this:that",
- },
- // Non-relative path with first element containing ":" should not be prepended with "./"
- {
- url: URL{
- Scheme: "http",
- Host: "www.google.com",
- Path: "this:that",
- },
- want: "http://www.google.com/this:that",
- },
- }
- func TestURLString(t *testing.T) {
- for _, tt := range urltests {
- u, err := Parse(tt.in)
- if err != nil {
- t.Errorf("Parse(%q) returned error %s", tt.in, err)
- continue
- }
- expected := tt.in
- if tt.roundtrip != "" {
- expected = tt.roundtrip
- }
- s := u.String()
- if s != expected {
- t.Errorf("Parse(%q).String() == %q (expected %q)", tt.in, s, expected)
- }
- }
- for _, tt := range stringURLTests {
- if got := tt.url.String(); got != tt.want {
- t.Errorf("%+v.String() = %q; want %q", tt.url, got, tt.want)
- }
- }
- }
- func TestURLRedacted(t *testing.T) {
- cases := []struct {
- name string
- url *URL
- want string
- }{
- {
- name: "non-blank Password",
- url: &URL{
- Scheme: "http",
- Host: "host.tld",
- Path: "this:that",
- User: UserPassword("user", "password"),
- },
- want: "http://user:xxxxx@host.tld/this:that",
- },
- {
- name: "blank Password",
- url: &URL{
- Scheme: "http",
- Host: "host.tld",
- Path: "this:that",
- User: User("user"),
- },
- want: "http://user@host.tld/this:that",
- },
- {
- name: "nil User",
- url: &URL{
- Scheme: "http",
- Host: "host.tld",
- Path: "this:that",
- User: UserPassword("", "password"),
- },
- want: "http://:xxxxx@host.tld/this:that",
- },
- {
- name: "blank Username, blank Password",
- url: &URL{
- Scheme: "http",
- Host: "host.tld",
- Path: "this:that",
- },
- want: "http://host.tld/this:that",
- },
- {
- name: "empty URL",
- url: &URL{},
- want: "",
- },
- {
- name: "nil URL",
- url: nil,
- want: "",
- },
- }
- for _, tt := range cases {
- t := t
- t.Run(tt.name, func(t *testing.T) {
- if g, w := tt.url.Redacted(), tt.want; g != w {
- t.Fatalf("got: %q\nwant: %q", g, w)
- }
- })
- }
- }
- type EscapeTest struct {
- in string
- out string
- err error
- }
- var unescapeTests = []EscapeTest{
- {
- "",
- "",
- nil,
- },
- {
- "abc",
- "abc",
- nil,
- },
- {
- "1%41",
- "1A",
- nil,
- },
- {
- "1%41%42%43",
- "1ABC",
- nil,
- },
- {
- "%4a",
- "J",
- nil,
- },
- {
- "%6F",
- "o",
- nil,
- },
- {
- "%", // not enough characters after %
- "",
- EscapeError("%"),
- },
- {
- "%a", // not enough characters after %
- "",
- EscapeError("%a"),
- },
- {
- "%1", // not enough characters after %
- "",
- EscapeError("%1"),
- },
- {
- "123%45%6", // not enough characters after %
- "",
- EscapeError("%6"),
- },
- {
- "%zzzzz", // invalid hex digits
- "",
- EscapeError("%zz"),
- },
- {
- "a+b",
- "a b",
- nil,
- },
- {
- "a%20b",
- "a b",
- nil,
- },
- }
- func TestUnescape(t *testing.T) {
- for _, tt := range unescapeTests {
- actual, err := QueryUnescape(tt.in)
- if actual != tt.out || (err != nil) != (tt.err != nil) {
- t.Errorf("QueryUnescape(%q) = %q, %s; want %q, %s", tt.in, actual, err, tt.out, tt.err)
- }
- in := tt.in
- out := tt.out
- if strings.Contains(tt.in, "+") {
- in = strings.ReplaceAll(tt.in, "+", "%20")
- actual, err := PathUnescape(in)
- if actual != tt.out || (err != nil) != (tt.err != nil) {
- t.Errorf("PathUnescape(%q) = %q, %s; want %q, %s", in, actual, err, tt.out, tt.err)
- }
- if tt.err == nil {
- s, err := QueryUnescape(strings.ReplaceAll(tt.in, "+", "XXX"))
- if err != nil {
- continue
- }
- in = tt.in
- out = strings.ReplaceAll(s, "XXX", "+")
- }
- }
- actual, err = PathUnescape(in)
- if actual != out || (err != nil) != (tt.err != nil) {
- t.Errorf("PathUnescape(%q) = %q, %s; want %q, %s", in, actual, err, out, tt.err)
- }
- }
- }
- var queryEscapeTests = []EscapeTest{
- {
- "",
- "",
- nil,
- },
- {
- "abc",
- "abc",
- nil,
- },
- {
- "one two",
- "one+two",
- nil,
- },
- {
- "10%",
- "10%25",
- nil,
- },
- {
- " ?&=#+%!<>#\"{}|\\^[]`☺\t:/@$'()*,;",
- "+%3F%26%3D%23%2B%25%21%3C%3E%23%22%7B%7D%7C%5C%5E%5B%5D%60%E2%98%BA%09%3A%2F%40%24%27%28%29%2A%2C%3B",
- nil,
- },
- }
- func TestQueryEscape(t *testing.T) {
- for _, tt := range queryEscapeTests {
- actual := QueryEscape(tt.in)
- if tt.out != actual {
- t.Errorf("QueryEscape(%q) = %q, want %q", tt.in, actual, tt.out)
- }
- // for bonus points, verify that escape:unescape is an identity.
- roundtrip, err := QueryUnescape(actual)
- if roundtrip != tt.in || err != nil {
- t.Errorf("QueryUnescape(%q) = %q, %s; want %q, %s", actual, roundtrip, err, tt.in, "[no error]")
- }
- }
- }
- var pathEscapeTests = []EscapeTest{
- {
- "",
- "",
- nil,
- },
- {
- "abc",
- "abc",
- nil,
- },
- {
- "abc+def",
- "abc+def",
- nil,
- },
- {
- "a/b",
- "a%2Fb",
- nil,
- },
- {
- "one two",
- "one%20two",
- nil,
- },
- {
- "10%",
- "10%25",
- nil,
- },
- {
- " ?&=#+%!<>#\"{}|\\^[]`☺\t:/@$'()*,;",
- "%20%3F&=%23+%25%21%3C%3E%23%22%7B%7D%7C%5C%5E%5B%5D%60%E2%98%BA%09:%2F@$%27%28%29%2A%2C%3B",
- nil,
- },
- }
- func TestPathEscape(t *testing.T) {
- for _, tt := range pathEscapeTests {
- actual := PathEscape(tt.in)
- if tt.out != actual {
- t.Errorf("PathEscape(%q) = %q, want %q", tt.in, actual, tt.out)
- }
- // for bonus points, verify that escape:unescape is an identity.
- roundtrip, err := PathUnescape(actual)
- if roundtrip != tt.in || err != nil {
- t.Errorf("PathUnescape(%q) = %q, %s; want %q, %s", actual, roundtrip, err, tt.in, "[no error]")
- }
- }
- }
- //var userinfoTests = []UserinfoTest{
- // {"user", "password", "user:password"},
- // {"foo:bar", "~!@#$%^&*()_+{}|[]\\-=`:;'\"<>?,./",
- // "foo%3Abar:~!%40%23$%25%5E&*()_+%7B%7D%7C%5B%5D%5C-=%60%3A;'%22%3C%3E?,.%2F"},
- //}
- type EncodeQueryTest struct {
- m Values
- expected string
- }
- var encodeQueryTests = []EncodeQueryTest{
- {nil, ""},
- {Values{"q": {"puppies"}, "oe": {"utf8"}}, "oe=utf8&q=puppies"},
- {Values{"q": {"dogs", "&", "7"}}, "q=dogs&q=%26&q=7"},
- {Values{
- "a": {"a1", "a2", "a3"},
- "b": {"b1", "b2", "b3"},
- "c": {"c1", "c2", "c3"},
- }, "a=a1&a=a2&a=a3&b=b1&b=b2&b=b3&c=c1&c=c2&c=c3"},
- }
- func TestEncodeQuery(t *testing.T) {
- for _, tt := range encodeQueryTests {
- if q := tt.m.Encode(); q != tt.expected {
- t.Errorf(`EncodeQuery(%+v) = %q, want %q`, tt.m, q, tt.expected)
- }
- }
- }
- var resolvePathTests = []struct {
- base, ref, expected string
- }{
- {"a/b", ".", "/a/"},
- {"a/b", "c", "/a/c"},
- {"a/b", "..", "/"},
- {"a/", "..", "/"},
- {"a/", "../..", "/"},
- {"a/b/c", "..", "/a/"},
- {"a/b/c", "../d", "/a/d"},
- {"a/b/c", ".././d", "/a/d"},
- {"a/b", "./..", "/"},
- {"a/./b", ".", "/a/"},
- {"a/../", ".", "/"},
- {"a/.././b", "c", "/c"},
- }
- func TestResolvePath(t *testing.T) {
- for _, test := range resolvePathTests {
- got := resolvePath(test.base, test.ref)
- if got != test.expected {
- t.Errorf("For %q + %q got %q; expected %q", test.base, test.ref, got, test.expected)
- }
- }
- }
- func BenchmarkResolvePath(b *testing.B) {
- b.ResetTimer()
- b.ReportAllocs()
- for i := 0; i < b.N; i++ {
- resolvePath("a/b/c", ".././d")
- }
- }
- var resolveReferenceTests = []struct {
- base, rel, expected string
- }{
- // Absolute URL references
- {"http://foo.com?a=b", "https://bar.com/", "https://bar.com/"},
- {"http://foo.com/", "https://bar.com/?a=b", "https://bar.com/?a=b"},
- {"http://foo.com/", "https://bar.com/?", "https://bar.com/?"},
- {"http://foo.com/bar", "mailto:foo@example.com", "mailto:foo@example.com"},
- // Path-absolute references
- {"http://foo.com/bar", "/baz", "http://foo.com/baz"},
- {"http://foo.com/bar?a=b#f", "/baz", "http://foo.com/baz"},
- {"http://foo.com/bar?a=b", "/baz?", "http://foo.com/baz?"},
- {"http://foo.com/bar?a=b", "/baz?c=d", "http://foo.com/baz?c=d"},
- // Multiple slashes
- {"http://foo.com/bar", "http://foo.com//baz", "http://foo.com//baz"},
- {"http://foo.com/bar", "http://foo.com///baz/quux", "http://foo.com///baz/quux"},
- // Scheme-relative
- {"https://foo.com/bar?a=b", "//bar.com/quux", "https://bar.com/quux"},
- // Path-relative references:
- // ... current directory
- {"http://foo.com", ".", "http://foo.com/"},
- {"http://foo.com/bar", ".", "http://foo.com/"},
- {"http://foo.com/bar/", ".", "http://foo.com/bar/"},
- // ... going down
- {"http://foo.com", "bar", "http://foo.com/bar"},
- {"http://foo.com/", "bar", "http://foo.com/bar"},
- {"http://foo.com/bar/baz", "quux", "http://foo.com/bar/quux"},
- // ... going up
- {"http://foo.com/bar/baz", "../quux", "http://foo.com/quux"},
- {"http://foo.com/bar/baz", "../../../../../quux", "http://foo.com/quux"},
- {"http://foo.com/bar", "..", "http://foo.com/"},
- {"http://foo.com/bar/baz", "./..", "http://foo.com/"},
- // ".." in the middle (issue 3560)
- {"http://foo.com/bar/baz", "quux/dotdot/../tail", "http://foo.com/bar/quux/tail"},
- {"http://foo.com/bar/baz", "quux/./dotdot/../tail", "http://foo.com/bar/quux/tail"},
- {"http://foo.com/bar/baz", "quux/./dotdot/.././tail", "http://foo.com/bar/quux/tail"},
- {"http://foo.com/bar/baz", "quux/./dotdot/./../tail", "http://foo.com/bar/quux/tail"},
- {"http://foo.com/bar/baz", "quux/./dotdot/dotdot/././../../tail", "http://foo.com/bar/quux/tail"},
- {"http://foo.com/bar/baz", "quux/./dotdot/dotdot/./.././../tail", "http://foo.com/bar/quux/tail"},
- {"http://foo.com/bar/baz", "quux/./dotdot/dotdot/dotdot/./../../.././././tail", "http://foo.com/bar/quux/tail"},
- {"http://foo.com/bar/baz", "quux/./dotdot/../dotdot/../dot/./tail/..", "http://foo.com/bar/quux/dot/"},
- // Remove any dot-segments prior to forming the target URI.
- // https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
- {"http://foo.com/dot/./dotdot/../foo/bar", "../baz", "http://foo.com/dot/baz"},
- // Triple dot isn't special
- {"http://foo.com/bar", "...", "http://foo.com/..."},
- // Fragment
- {"http://foo.com/bar", ".#frag", "http://foo.com/#frag"},
- {"http://example.org/", "#!$&%27()*+,;=", "http://example.org/#!$&%27()*+,;="},
- // Paths with escaping (issue 16947).
- {"http://foo.com/foo%2fbar/", "../baz", "http://foo.com/baz"},
- {"http://foo.com/1/2%2f/3%2f4/5", "../../a/b/c", "http://foo.com/1/a/b/c"},
- {"http://foo.com/1/2/3", "./a%2f../../b/..%2fc", "http://foo.com/1/2/b/..%2fc"},
- {"http://foo.com/1/2%2f/3%2f4/5", "./a%2f../b/../c", "http://foo.com/1/2%2f/3%2f4/a%2f../c"},
- {"http://foo.com/foo%20bar/", "../baz", "http://foo.com/baz"},
- {"http://foo.com/foo", "../bar%2fbaz", "http://foo.com/bar%2fbaz"},
- {"http://foo.com/foo%2dbar/", "./baz-quux", "http://foo.com/foo%2dbar/baz-quux"},
- // RFC 3986: Normal Examples
- // https://datatracker.ietf.org/doc/html/rfc3986#section-5.4.1
- {"http://a/b/c/d;p?q", "g:h", "g:h"},
- {"http://a/b/c/d;p?q", "g", "http://a/b/c/g"},
- {"http://a/b/c/d;p?q", "./g", "http://a/b/c/g"},
- {"http://a/b/c/d;p?q", "g/", "http://a/b/c/g/"},
- {"http://a/b/c/d;p?q", "/g", "http://a/g"},
- {"http://a/b/c/d;p?q", "//g", "http://g"},
- {"http://a/b/c/d;p?q", "?y", "http://a/b/c/d;p?y"},
- {"http://a/b/c/d;p?q", "g?y", "http://a/b/c/g?y"},
- {"http://a/b/c/d;p?q", "#s", "http://a/b/c/d;p?q#s"},
- {"http://a/b/c/d;p?q", "g#s", "http://a/b/c/g#s"},
- {"http://a/b/c/d;p?q", "g?y#s", "http://a/b/c/g?y#s"},
- {"http://a/b/c/d;p?q", ";x", "http://a/b/c/;x"},
- {"http://a/b/c/d;p?q", "g;x", "http://a/b/c/g;x"},
- {"http://a/b/c/d;p?q", "g;x?y#s", "http://a/b/c/g;x?y#s"},
- {"http://a/b/c/d;p?q", "", "http://a/b/c/d;p?q"},
- {"http://a/b/c/d;p?q", ".", "http://a/b/c/"},
- {"http://a/b/c/d;p?q", "./", "http://a/b/c/"},
- {"http://a/b/c/d;p?q", "..", "http://a/b/"},
- {"http://a/b/c/d;p?q", "../", "http://a/b/"},
- {"http://a/b/c/d;p?q", "../g", "http://a/b/g"},
- {"http://a/b/c/d;p?q", "../..", "http://a/"},
- {"http://a/b/c/d;p?q", "../../", "http://a/"},
- {"http://a/b/c/d;p?q", "../../g", "http://a/g"},
- // RFC 3986: Abnormal Examples
- // https://datatracker.ietf.org/doc/html/rfc3986#section-5.4.2
- {"http://a/b/c/d;p?q", "../../../g", "http://a/g"},
- {"http://a/b/c/d;p?q", "../../../../g", "http://a/g"},
- {"http://a/b/c/d;p?q", "/./g", "http://a/g"},
- {"http://a/b/c/d;p?q", "/../g", "http://a/g"},
- {"http://a/b/c/d;p?q", "g.", "http://a/b/c/g."},
- {"http://a/b/c/d;p?q", ".g", "http://a/b/c/.g"},
- {"http://a/b/c/d;p?q", "g..", "http://a/b/c/g.."},
- {"http://a/b/c/d;p?q", "..g", "http://a/b/c/..g"},
- {"http://a/b/c/d;p?q", "./../g", "http://a/b/g"},
- {"http://a/b/c/d;p?q", "./g/.", "http://a/b/c/g/"},
- {"http://a/b/c/d;p?q", "g/./h", "http://a/b/c/g/h"},
- {"http://a/b/c/d;p?q", "g/../h", "http://a/b/c/h"},
- {"http://a/b/c/d;p?q", "g;x=1/./y", "http://a/b/c/g;x=1/y"},
- {"http://a/b/c/d;p?q", "g;x=1/../y", "http://a/b/c/y"},
- {"http://a/b/c/d;p?q", "g?y/./x", "http://a/b/c/g?y/./x"},
- {"http://a/b/c/d;p?q", "g?y/../x", "http://a/b/c/g?y/../x"},
- {"http://a/b/c/d;p?q", "g#s/./x", "http://a/b/c/g#s/./x"},
- {"http://a/b/c/d;p?q", "g#s/../x", "http://a/b/c/g#s/../x"},
- // Extras.
- {"https://a/b/c/d;p?q", "//g?q", "https://g?q"},
- {"https://a/b/c/d;p?q", "//g#s", "https://g#s"},
- {"https://a/b/c/d;p?q", "//g/d/e/f?y#s", "https://g/d/e/f?y#s"},
- {"https://a/b/c/d;p#s", "?y", "https://a/b/c/d;p?y"},
- {"https://a/b/c/d;p?q#s", "?y", "https://a/b/c/d;p?y"},
- // Empty path and query but with ForceQuery (issue 46033).
- {"https://a/b/c/d;p?q#s", "?", "https://a/b/c/d;p?"},
- }
- func TestResolveReference(t *testing.T) {
- mustParse := func(url string) *URL {
- u, err := Parse(url)
- if err != nil {
- t.Fatalf("Parse(%q) got err %v", url, err)
- }
- return u
- }
- opaque := &URL{Scheme: "scheme", Opaque: "opaque"}
- for _, test := range resolveReferenceTests {
- base := mustParse(test.base)
- rel := mustParse(test.rel)
- url := base.ResolveReference(rel)
- if got := url.String(); got != test.expected {
- t.Errorf("URL(%q).ResolveReference(%q)\ngot %q\nwant %q", test.base, test.rel, got, test.expected)
- }
- // Ensure that new instances are returned.
- if base == url {
- t.Errorf("Expected URL.ResolveReference to return new URL instance.")
- }
- // Test the convenience wrapper too.
- url, err := base.Parse(test.rel)
- if err != nil {
- t.Errorf("URL(%q).Parse(%q) failed: %v", test.base, test.rel, err)
- } else if got := url.String(); got != test.expected {
- t.Errorf("URL(%q).Parse(%q)\ngot %q\nwant %q", test.base, test.rel, got, test.expected)
- } else if base == url {
- // Ensure that new instances are returned for the wrapper too.
- t.Errorf("Expected URL.Parse to return new URL instance.")
- }
- // Ensure Opaque resets the URL.
- url = base.ResolveReference(opaque)
- if *url != *opaque {
- t.Errorf("ResolveReference failed to resolve opaque URL:\ngot %#v\nwant %#v", url, opaque)
- }
- // Test the convenience wrapper with an opaque URL too.
- url, err = base.Parse("scheme:opaque")
- if err != nil {
- t.Errorf(`URL(%q).Parse("scheme:opaque") failed: %v`, test.base, err)
- } else if *url != *opaque {
- t.Errorf("Parse failed to resolve opaque URL:\ngot %#v\nwant %#v", opaque, url)
- } else if base == url {
- // Ensure that new instances are returned, again.
- t.Errorf("Expected URL.Parse to return new URL instance.")
- }
- }
- }
- func TestQueryValues(t *testing.T) {
- u, _ := Parse("http://x.com?foo=bar&bar=1&bar=2&baz")
- v := u.Query()
- if len(v) != 3 {
- t.Errorf("got %d keys in Query values, want 3", len(v))
- }
- if g, e := v.Get("foo"), "bar"; g != e {
- t.Errorf("Get(foo) = %q, want %q", g, e)
- }
- // Case sensitive:
- if g, e := v.Get("Foo"), ""; g != e {
- t.Errorf("Get(Foo) = %q, want %q", g, e)
- }
- if g, e := v.Get("bar"), "1"; g != e {
- t.Errorf("Get(bar) = %q, want %q", g, e)
- }
- if g, e := v.Get("baz"), ""; g != e {
- t.Errorf("Get(baz) = %q, want %q", g, e)
- }
- if h, e := v.Has("foo"), true; h != e {
- t.Errorf("Has(foo) = %t, want %t", h, e)
- }
- if h, e := v.Has("bar"), true; h != e {
- t.Errorf("Has(bar) = %t, want %t", h, e)
- }
- if h, e := v.Has("baz"), true; h != e {
- t.Errorf("Has(baz) = %t, want %t", h, e)
- }
- if h, e := v.Has("noexist"), false; h != e {
- t.Errorf("Has(noexist) = %t, want %t", h, e)
- }
- v.Del("bar")
- if g, e := v.Get("bar"), ""; g != e {
- t.Errorf("second Get(bar) = %q, want %q", g, e)
- }
- }
- type parseTest struct {
- query string
- out Values
- ok bool
- }
- var parseTests = []parseTest{
- {
- query: "a=1",
- out: Values{"a": []string{"1"}},
- ok: true,
- },
- {
- query: "a=1&b=2",
- out: Values{"a": []string{"1"}, "b": []string{"2"}},
- ok: true,
- },
- {
- query: "a=1&a=2&a=banana",
- out: Values{"a": []string{"1", "2", "banana"}},
- ok: true,
- },
- {
- query: "ascii=%3Ckey%3A+0x90%3E",
- out: Values{"ascii": []string{"<key: 0x90>"}},
- ok: true,
- }, {
- query: "a=1;b=2",
- out: Values{},
- ok: false,
- }, {
- query: "a;b=1",
- out: Values{},
- ok: false,
- }, {
- query: "a=%3B", // hex encoding for semicolon
- out: Values{"a": []string{";"}},
- ok: true,
- },
- {
- query: "a%3Bb=1",
- out: Values{"a;b": []string{"1"}},
- ok: true,
- },
- {
- query: "a=1&a=2;a=banana",
- out: Values{"a": []string{"1"}},
- ok: false,
- },
- {
- query: "a;b&c=1",
- out: Values{"c": []string{"1"}},
- ok: false,
- },
- {
- query: "a=1&b=2;a=3&c=4",
- out: Values{"a": []string{"1"}, "c": []string{"4"}},
- ok: false,
- },
- {
- query: "a=1&b=2;c=3",
- out: Values{"a": []string{"1"}},
- ok: false,
- },
- {
- query: ";",
- out: Values{},
- ok: false,
- },
- {
- query: "a=1;",
- out: Values{},
- ok: false,
- },
- {
- query: "a=1&;",
- out: Values{"a": []string{"1"}},
- ok: false,
- },
- {
- query: ";a=1&b=2",
- out: Values{"b": []string{"2"}},
- ok: false,
- },
- {
- query: "a=1&b=2;",
- out: Values{"a": []string{"1"}},
- ok: false,
- },
- }
- func TestParseQuery(t *testing.T) {
- for _, test := range parseTests {
- t.Run(test.query, func(t *testing.T) {
- form, err := ParseQuery(test.query)
- if test.ok != (err == nil) {
- want := "<error>"
- if test.ok {
- want = "<nil>"
- }
- t.Errorf("Unexpected error: %v, want %v", err, want)
- }
- if len(form) != len(test.out) {
- t.Errorf("len(form) = %d, want %d", len(form), len(test.out))
- }
- for k, evs := range test.out {
- vs, ok := form[k]
- if !ok {
- t.Errorf("Missing key %q", k)
- continue
- }
- if len(vs) != len(evs) {
- t.Errorf("len(form[%q]) = %d, want %d", k, len(vs), len(evs))
- continue
- }
- for j, ev := range evs {
- if v := vs[j]; v != ev {
- t.Errorf("form[%q][%d] = %q, want %q", k, j, v, ev)
- }
- }
- }
- })
- }
- }
- type RequestURITest struct {
- url *URL
- out string
- }
- var requritests = []RequestURITest{
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "",
- },
- "/",
- },
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "/a b",
- },
- "/a%20b",
- },
- // golang.org/issue/4860 variant 1
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Opaque: "/%2F/%2F/",
- },
- "/%2F/%2F/",
- },
- // golang.org/issue/4860 variant 2
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Opaque: "//other.example.com/%2F/%2F/",
- },
- "http://other.example.com/%2F/%2F/",
- },
- // better fix for issue 4860
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "/////",
- RawPath: "/%2F/%2F/",
- },
- "/%2F/%2F/",
- },
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "/////",
- RawPath: "/WRONG/", // ignored because doesn't match Path
- },
- "/////",
- },
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "/a b",
- RawQuery: "q=go+language",
- },
- "/a%20b?q=go+language",
- },
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "/a b",
- RawPath: "/a b", // ignored because invalid
- RawQuery: "q=go+language",
- },
- "/a%20b?q=go+language",
- },
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "/a?b",
- RawPath: "/a?b", // ignored because invalid
- RawQuery: "q=go+language",
- },
- "/a%3Fb?q=go+language",
- },
- {
- &URL{
- Scheme: "myschema",
- Opaque: "opaque",
- },
- "opaque",
- },
- {
- &URL{
- Scheme: "myschema",
- Opaque: "opaque",
- RawQuery: "q=go+language",
- },
- "opaque?q=go+language",
- },
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "//foo",
- },
- "//foo",
- },
- {
- &URL{
- Scheme: "http",
- Host: "example.com",
- Path: "/foo",
- ForceQuery: true,
- },
- "/foo?",
- },
- }
- func TestRequestURI(t *testing.T) {
- for _, tt := range requritests {
- s := tt.url.RequestURI()
- if s != tt.out {
- t.Errorf("%#v.RequestURI() == %q (expected %q)", tt.url, s, tt.out)
- }
- }
- }
- func TestParseFailure(t *testing.T) {
- // Test that the first parse error is returned.
- const url = "%gh&%ij"
- _, err := ParseQuery(url)
- errStr := fmt.Sprint(err)
- if !strings.Contains(errStr, "%gh") {
- t.Errorf(`ParseQuery(%q) returned error %q, want something containing %q"`, url, errStr, "%gh")
- }
- }
- func TestParseErrors(t *testing.T) {
- tests := []struct {
- in string
- wantErr bool
- }{
- {"http://[::1]", false},
- {"http://[::1]:80", false},
- {"http://[::1]:namedport", true}, // rfc3986 3.2.3
- {"http://x:namedport", true}, // rfc3986 3.2.3
- {"http://[::1]/", false},
- {"http://[::1]a", true},
- {"http://[::1]%23", true},
- {"http://[::1%25en0]", false}, // valid zone id
- {"http://[::1]:", false}, // colon, but no port OK
- {"http://x:", false}, // colon, but no port OK
- {"http://[::1]:%38%30", true}, // not allowed: % encoding only for non-ASCII
- {"http://[::1%25%41]", false}, // RFC 6874 allows over-escaping in zone
- {"http://[%10::1]", true}, // no %xx escapes in IP address
- {"http://[::1]/%48", false}, // %xx in path is fine
- {"http://%41:8080/", true}, // not allowed: % encoding only for non-ASCII
- {"mysql://x@y(z:123)/foo", true}, // not well-formed per RFC 3986, golang.org/issue/33646
- {"mysql://x@y(1.2.3.4:123)/foo", true},
- {" http://foo.com", true}, // invalid character in schema
- {"ht tp://foo.com", true}, // invalid character in schema
- {"ahttp://foo.com", false}, // valid schema characters
- {"1http://foo.com", true}, // invalid character in schema
- {"http://[]%20%48%54%54%50%2f%31%2e%31%0a%4d%79%48%65%61%64%65%72%3a%20%31%32%33%0a%0a/", true}, // golang.org/issue/11208
- {"http://a b.com/", true}, // no space in host name please
- {"cache_object://foo", true}, // scheme cannot have _, relative path cannot have : in first segment
- {"cache_object:foo", true},
- {"cache_object:foo/bar", true},
- {"cache_object/:foo/bar", false},
- }
- for _, tt := range tests {
- u, err := Parse(tt.in)
- if tt.wantErr {
- if err == nil {
- t.Errorf("Parse(%q) = %#v; want an error", tt.in, u)
- }
- continue
- }
- if err != nil {
- t.Errorf("Parse(%q) = %v; want no error", tt.in, err)
- }
- }
- }
- // Issue 11202
- func TestStarRequest(t *testing.T) {
- u, err := Parse("*")
- if err != nil {
- t.Fatal(err)
- }
- if got, want := u.RequestURI(), "*"; got != want {
- t.Errorf("RequestURI = %q; want %q", got, want)
- }
- }
- type shouldEscapeTest struct {
- in byte
- mode encoding
- escape bool
- }
- var shouldEscapeTests = []shouldEscapeTest{
- // Unreserved characters (§2.3)
- {'a', encodePath, false},
- {'a', encodeUserPassword, false},
- {'a', encodeQueryComponent, false},
- {'a', encodeFragment, false},
- {'a', encodeHost, false},
- {'z', encodePath, false},
- {'A', encodePath, false},
- {'Z', encodePath, false},
- {'0', encodePath, false},
- {'9', encodePath, false},
- {'-', encodePath, false},
- {'-', encodeUserPassword, false},
- {'-', encodeQueryComponent, false},
- {'-', encodeFragment, false},
- {'.', encodePath, false},
- {'_', encodePath, false},
- {'~', encodePath, false},
- // User information (§3.2.1)
- {':', encodeUserPassword, true},
- {'/', encodeUserPassword, true},
- {'?', encodeUserPassword, true},
- {'@', encodeUserPassword, true},
- {'$', encodeUserPassword, false},
- {'&', encodeUserPassword, false},
- {'+', encodeUserPassword, false},
- {',', encodeUserPassword, false},
- {';', encodeUserPassword, false},
- {'=', encodeUserPassword, false},
- // Host (IP address, IPv6 address, registered name, port suffix; §3.2.2)
- {'!', encodeHost, false},
- {'$', encodeHost, false},
- {'&', encodeHost, false},
- {'\'', encodeHost, false},
- {'(', encodeHost, false},
- {')', encodeHost, false},
- {'*', encodeHost, false},
- {'+', encodeHost, false},
- {',', encodeHost, false},
- {';', encodeHost, false},
- {'=', encodeHost, false},
- {':', encodeHost, false},
- {'[', encodeHost, false},
- {']', encodeHost, false},
- {'0', encodeHost, false},
- {'9', encodeHost, false},
- {'A', encodeHost, false},
- {'z', encodeHost, false},
- {'_', encodeHost, false},
- {'-', encodeHost, false},
- {'.', encodeHost, false},
- }
- func TestShouldEscape(t *testing.T) {
- for _, tt := range shouldEscapeTests {
- if shouldEscape(tt.in, tt.mode) != tt.escape {
- t.Errorf("shouldEscape(%q, %v) returned %v; expected %v", tt.in, tt.mode, !tt.escape, tt.escape)
- }
- }
- }
- type timeoutError struct {
- timeout bool
- }
- func (e *timeoutError) Error() string { return "timeout error" }
- func (e *timeoutError) Timeout() bool { return e.timeout }
- type temporaryError struct {
- temporary bool
- }
- func (e *temporaryError) Error() string { return "temporary error" }
- func (e *temporaryError) Temporary() bool { return e.temporary }
- type timeoutTemporaryError struct {
- timeoutError
- temporaryError
- }
- func (e *timeoutTemporaryError) Error() string { return "timeout/temporary error" }
- var netErrorTests = []struct {
- err error
- timeout bool
- temporary bool
- }{{
- err: &Error{"Get", "http://google.com/", &timeoutError{timeout: true}},
- timeout: true,
- temporary: false,
- }, {
- err: &Error{"Get", "http://google.com/", &timeoutError{timeout: false}},
- timeout: false,
- temporary: false,
- }, {
- err: &Error{"Get", "http://google.com/", &temporaryError{temporary: true}},
- timeout: false,
- temporary: true,
- }, {
- err: &Error{"Get", "http://google.com/", &temporaryError{temporary: false}},
- timeout: false,
- temporary: false,
- }, {
- err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: true}, temporaryError{temporary: true}}},
- timeout: true,
- temporary: true,
- }, {
- err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: false}, temporaryError{temporary: true}}},
- timeout: false,
- temporary: true,
- }, {
- err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: true}, temporaryError{temporary: false}}},
- timeout: true,
- temporary: false,
- }, {
- err: &Error{"Get", "http://google.com/", &timeoutTemporaryError{timeoutError{timeout: false}, temporaryError{temporary: false}}},
- timeout: false,
- temporary: false,
- }, {
- err: &Error{"Get", "http://google.com/", io.EOF},
- timeout: false,
- temporary: false,
- }}
- // Test that url.Error implements net.Error and that it forwards
- func TestURLErrorImplementsNetError(t *testing.T) {
- for i, tt := range netErrorTests {
- err, ok := tt.err.(net.Error)
- if !ok {
- t.Errorf("%d: %T does not implement net.Error", i+1, tt.err)
- continue
- }
- if err.Timeout() != tt.timeout {
- t.Errorf("%d: err.Timeout(): got %v, want %v", i+1, err.Timeout(), tt.timeout)
- continue
- }
- if err.Temporary() != tt.temporary {
- t.Errorf("%d: err.Temporary(): got %v, want %v", i+1, err.Temporary(), tt.temporary)
- }
- }
- }
- func TestURLHostnameAndPort(t *testing.T) {
- tests := []struct {
- in string // URL.Host field
- host string
- port string
- }{
- {"foo.com:80", "foo.com", "80"},
- {"foo.com", "foo.com", ""},
- {"foo.com:", "foo.com", ""},
- {"FOO.COM", "FOO.COM", ""}, // no canonicalization
- {"1.2.3.4", "1.2.3.4", ""},
- {"1.2.3.4:80", "1.2.3.4", "80"},
- {"[1:2:3:4]", "1:2:3:4", ""},
- {"[1:2:3:4]:80", "1:2:3:4", "80"},
- {"[::1]:80", "::1", "80"},
- {"[::1]", "::1", ""},
- {"[::1]:", "::1", ""},
- {"localhost", "localhost", ""},
- {"localhost:443", "localhost", "443"},
- {"some.super.long.domain.example.org:8080", "some.super.long.domain.example.org", "8080"},
- {"[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:17000", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "17000"},
- {"[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", ""},
- // Ensure that even when not valid, Host is one of "Hostname",
- // "Hostname:Port", "[Hostname]" or "[Hostname]:Port".
- // See https://golang.org/issue/29098.
- {"[google.com]:80", "google.com", "80"},
- {"google.com]:80", "google.com]", "80"},
- {"google.com:80_invalid_port", "google.com:80_invalid_port", ""},
- {"[::1]extra]:80", "::1]extra", "80"},
- {"google.com]extra:extra", "google.com]extra:extra", ""},
- }
- for _, tt := range tests {
- u := &URL{Host: tt.in}
- host, port := u.Hostname(), u.Port()
- if host != tt.host {
- t.Errorf("Hostname for Host %q = %q; want %q", tt.in, host, tt.host)
- }
- if port != tt.port {
- t.Errorf("Port for Host %q = %q; want %q", tt.in, port, tt.port)
- }
- }
- }
- var _ encodingPkg.BinaryMarshaler = (*URL)(nil)
- var _ encodingPkg.BinaryUnmarshaler = (*URL)(nil)
- func TestJSON(t *testing.T) {
- u, err := Parse("https://www.google.com/x?y=z")
- if err != nil {
- t.Fatal(err)
- }
- js, err := json.Marshal(u)
- if err != nil {
- t.Fatal(err)
- }
- // If only we could implement TextMarshaler/TextUnmarshaler,
- // this would work:
- //
- // if string(js) != strconv.Quote(u.String()) {
- // t.Errorf("json encoding: %s\nwant: %s\n", js, strconv.Quote(u.String()))
- // }
- u1 := new(URL)
- err = json.Unmarshal(js, u1)
- if err != nil {
- t.Fatal(err)
- }
- if u1.String() != u.String() {
- t.Errorf("json decoded to: %s\nwant: %s\n", u1, u)
- }
- }
- func TestGob(t *testing.T) {
- u, err := Parse("https://www.google.com/x?y=z")
- if err != nil {
- t.Fatal(err)
- }
- var w bytes.Buffer
- err = gob.NewEncoder(&w).Encode(u)
- if err != nil {
- t.Fatal(err)
- }
- u1 := new(URL)
- err = gob.NewDecoder(&w).Decode(u1)
- if err != nil {
- t.Fatal(err)
- }
- if u1.String() != u.String() {
- t.Errorf("json decoded to: %s\nwant: %s\n", u1, u)
- }
- }
- func TestNilUser(t *testing.T) {
- defer func() {
- if v := recover(); v != nil {
- t.Fatalf("unexpected panic: %v", v)
- }
- }()
- u, err := Parse("http://foo.com/")
- if err != nil {
- t.Fatalf("parse err: %v", err)
- }
- if v := u.User.Username(); v != "" {
- t.Fatalf("expected empty username, got %s", v)
- }
- if v, ok := u.User.Password(); v != "" || ok {
- t.Fatalf("expected empty password, got %s (%v)", v, ok)
- }
- if v := u.User.String(); v != "" {
- t.Fatalf("expected empty string, got %s", v)
- }
- }
- func TestInvalidUserPassword(t *testing.T) {
- _, err := Parse("http://user^:passwo^rd@foo.com/")
- if got, wantsub := fmt.Sprint(err), "net/url: invalid userinfo"; !strings.Contains(got, wantsub) {
- t.Errorf("error = %q; want substring %q", got, wantsub)
- }
- }
- func TestRejectControlCharacters(t *testing.T) {
- tests := []string{
- "http://foo.com/?foo\nbar",
- "http\r://foo.com/",
- "http://foo\x7f.com/",
- }
- for _, s := range tests {
- _, err := Parse(s)
- const wantSub = "net/url: invalid control character in URL"
- if got := fmt.Sprint(err); !strings.Contains(got, wantSub) {
- t.Errorf("Parse(%q) error = %q; want substring %q", s, got, wantSub)
- }
- }
- // But don't reject non-ASCII CTLs, at least for now:
- if _, err := Parse("http://foo.com/ctl\x80"); err != nil {
- t.Errorf("error parsing URL with non-ASCII control byte: %v", err)
- }
- }
- var escapeBenchmarks = []struct {
- unescaped string
- query string
- path string
- }{
- {
- unescaped: "one two",
- query: "one+two",
- path: "one%20two",
- },
- {
- unescaped: "Фотки собак",
- query: "%D0%A4%D0%BE%D1%82%D0%BA%D0%B8+%D1%81%D0%BE%D0%B1%D0%B0%D0%BA",
- path: "%D0%A4%D0%BE%D1%82%D0%BA%D0%B8%20%D1%81%D0%BE%D0%B1%D0%B0%D0%BA",
- },
- {
- unescaped: "shortrun(break)shortrun",
- query: "shortrun%28break%29shortrun",
- path: "shortrun%28break%29shortrun",
- },
- {
- unescaped: "longerrunofcharacters(break)anotherlongerrunofcharacters",
- query: "longerrunofcharacters%28break%29anotherlongerrunofcharacters",
- path: "longerrunofcharacters%28break%29anotherlongerrunofcharacters",
- },
- {
- unescaped: strings.Repeat("padded/with+various%characters?that=need$some@escaping+paddedsowebreak/256bytes", 4),
- query: strings.Repeat("padded%2Fwith%2Bvarious%25characters%3Fthat%3Dneed%24some%40escaping%2Bpaddedsowebreak%2F256bytes", 4),
- path: strings.Repeat("padded%2Fwith+various%25characters%3Fthat=need$some@escaping+paddedsowebreak%2F256bytes", 4),
- },
- }
- func BenchmarkQueryEscape(b *testing.B) {
- for _, tc := range escapeBenchmarks {
- b.Run("", func(b *testing.B) {
- b.ReportAllocs()
- var g string
- for i := 0; i < b.N; i++ {
- g = QueryEscape(tc.unescaped)
- }
- b.StopTimer()
- if g != tc.query {
- b.Errorf("QueryEscape(%q) == %q, want %q", tc.unescaped, g, tc.query)
- }
- })
- }
- }
- func BenchmarkPathEscape(b *testing.B) {
- for _, tc := range escapeBenchmarks {
- b.Run("", func(b *testing.B) {
- b.ReportAllocs()
- var g string
- for i := 0; i < b.N; i++ {
- g = PathEscape(tc.unescaped)
- }
- b.StopTimer()
- if g != tc.path {
- b.Errorf("PathEscape(%q) == %q, want %q", tc.unescaped, g, tc.path)
- }
- })
- }
- }
- func BenchmarkQueryUnescape(b *testing.B) {
- for _, tc := range escapeBenchmarks {
- b.Run("", func(b *testing.B) {
- b.ReportAllocs()
- var g string
- for i := 0; i < b.N; i++ {
- g, _ = QueryUnescape(tc.query)
- }
- b.StopTimer()
- if g != tc.unescaped {
- b.Errorf("QueryUnescape(%q) == %q, want %q", tc.query, g, tc.unescaped)
- }
- })
- }
- }
- func BenchmarkPathUnescape(b *testing.B) {
- for _, tc := range escapeBenchmarks {
- b.Run("", func(b *testing.B) {
- b.ReportAllocs()
- var g string
- for i := 0; i < b.N; i++ {
- g, _ = PathUnescape(tc.path)
- }
- b.StopTimer()
- if g != tc.unescaped {
- b.Errorf("PathUnescape(%q) == %q, want %q", tc.path, g, tc.unescaped)
- }
- })
- }
- }
|