1396 lines
42 KiB
Gleam
1396 lines
42 KiB
Gleam
import gleam/list
|
|
import gleam/option.{None, Some}
|
|
import gleeunit/should
|
|
import gluri as uri
|
|
import gluri/types.{Uri, empty_uri}
|
|
import startest.{describe, it}
|
|
|
|
pub fn main() {
|
|
startest.run(startest.default_config())
|
|
}
|
|
|
|
pub fn parse_scheme_tests() {
|
|
describe("scheme parsing", [
|
|
it("simple parse", fn() {
|
|
uri.parse("") |> should.equal(Ok(types.empty_uri))
|
|
uri.parse("foo")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "foo")))
|
|
uri.parse("foo:")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, scheme: Some("foo"))))
|
|
uri.parse("foo:bar:nisse")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), path: "bar:nisse"),
|
|
))
|
|
uri.parse("foo://")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), host: Some("")),
|
|
))
|
|
uri.parse("foo:///")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), host: Some(""), path: "/"),
|
|
))
|
|
uri.parse("foo:////")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), host: Some(""), path: "//"),
|
|
))
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_userinfo_tests() {
|
|
describe("userinfo parsing", [
|
|
it("simple parse", fn() {
|
|
uri.parse("user:password@localhost")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("user"), path: "password@localhost"),
|
|
))
|
|
uri.parse("user@")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "user@")))
|
|
uri.parse("/user@")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "/user@")))
|
|
uri.parse("user@localhost")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "user@localhost")))
|
|
uri.parse("//user@localhost")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, userinfo: Some("user"), host: Some("localhost")),
|
|
))
|
|
uri.parse("//user:password@localhost")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
userinfo: Some("user:password"),
|
|
host: Some("localhost"),
|
|
),
|
|
))
|
|
uri.parse("foo:/user@")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), path: "/user@"),
|
|
))
|
|
uri.parse("foo://user@localhost")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
userinfo: Some("user"),
|
|
host: Some("localhost"),
|
|
),
|
|
))
|
|
uri.parse("foo://user:password@localhost")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
userinfo: Some("user:password"),
|
|
host: Some("localhost"),
|
|
),
|
|
))
|
|
}),
|
|
it("percent encoding", fn() {
|
|
uri.parse("user:%E5%90%88@%E6%B0%97%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("user"),
|
|
path: "%E5%90%88@%E6%B0%97%E9%81%93",
|
|
),
|
|
))
|
|
uri.parse("%E5%90%88%E6%B0%97%E9%81%93@")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "%E5%90%88%E6%B0%97%E9%81%93@"),
|
|
))
|
|
uri.parse("/%E5%90%88%E6%B0%97%E9%81%93@")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "/%E5%90%88%E6%B0%97%E9%81%93@"),
|
|
))
|
|
uri.parse("%E5%90%88@%E6%B0%97%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "%E5%90%88@%E6%B0%97%E9%81%93"),
|
|
))
|
|
uri.parse("//%E5%90%88@%E6%B0%97%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("%E6%B0%97%E9%81%93"),
|
|
userinfo: Some("%E5%90%88"),
|
|
),
|
|
))
|
|
uri.parse("//%E5%90%88:%E6%B0%97@%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("%E9%81%93"),
|
|
userinfo: Some("%E5%90%88:%E6%B0%97"),
|
|
),
|
|
))
|
|
uri.parse("foo:/%E5%90%88%E6%B0%97%E9%81%93@")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
path: "/%E5%90%88%E6%B0%97%E9%81%93@",
|
|
),
|
|
))
|
|
uri.parse("foo://%E5%90%88@%E6%B0%97%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
userinfo: Some("%E5%90%88"),
|
|
host: Some("%E6%B0%97%E9%81%93"),
|
|
),
|
|
))
|
|
uri.parse("foo://%E5%90%88:%E6%B0%97@%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
userinfo: Some("%E5%90%88:%E6%B0%97"),
|
|
host: Some("%E9%81%93"),
|
|
),
|
|
))
|
|
uri.parse("//%E5%90%88@%E6%B0%97%E9%81%93@") |> should.be_error
|
|
uri.parse("foo://%E5%90%88@%E6%B0%97%E9%81%93@") |> should.be_error
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_host_tests() {
|
|
describe("host parsing", [
|
|
it("simple parse", fn() {
|
|
uri.parse("//hostname")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some("hostname"))))
|
|
uri.parse("foo://hostname")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), host: Some("hostname")),
|
|
))
|
|
uri.parse("foo://user@hostname")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
userinfo: Some("user"),
|
|
host: Some("hostname"),
|
|
),
|
|
))
|
|
}),
|
|
it("ipv4 parse", fn() {
|
|
uri.parse("//127.0.0.1")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some("127.0.0.1"))))
|
|
uri.parse("//127.0.0.1/over/there")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some("127.0.0.1"), path: "/over/there"),
|
|
))
|
|
uri.parse("//127.0.0.1?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("127.0.0.1"),
|
|
query: Some("name=ferret"),
|
|
),
|
|
))
|
|
uri.parse("//127.0.0.1#nose")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some("127.0.0.1"), fragment: Some("nose")),
|
|
))
|
|
|
|
uri.parse("//127.0.0.x")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some("127.0.0.x"))))
|
|
uri.parse("//1227.0.0.1")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some("1227.0.0.1"))))
|
|
}),
|
|
it("ipv6 parse", fn() {
|
|
uri.parse("//[::127.0.0.1]")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some("::127.0.0.1"))))
|
|
uri.parse("//[2001:0db8:0000:0000:0000:0000:1428:07ab]")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("2001:0db8:0000:0000:0000:0000:1428:07ab"),
|
|
),
|
|
))
|
|
uri.parse("//[::127.0.0.1]/over/there")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some("::127.0.0.1"), path: "/over/there"),
|
|
))
|
|
uri.parse("//[::127.0.0.1]?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("::127.0.0.1"),
|
|
query: Some("name=ferret"),
|
|
),
|
|
))
|
|
uri.parse("//[::127.0.0.1]#nose")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("::127.0.0.1"),
|
|
fragment: Some("nose"),
|
|
),
|
|
))
|
|
|
|
uri.parse("//[::127.0.0.x]") |> should.be_error
|
|
uri.parse("//[::1227.0.0.1]") |> should.be_error
|
|
uri.parse("//[2001:0db8:0000:0000:0000:0000:1428:G7ab]")
|
|
|> should.be_error
|
|
}),
|
|
it("ipvFuture parse", fn() {
|
|
uri.parse("//[v9.abc:def]")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some("v9.abc:def"))))
|
|
uri.parse("//[v9b.abc:def]")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some("v9b.abc:def"))))
|
|
|
|
uri.parse("//[vz.abc:def]") |> should.be_error
|
|
uri.parse("//[va1.abc:d@ef]") |> should.be_error
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_port_tests() {
|
|
describe("port parsing", [
|
|
it("simple parse", fn() {
|
|
uri.parse("/:8042")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "/:8042")))
|
|
uri.parse("//:8042")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some(""), port: Some(8042)),
|
|
))
|
|
uri.parse("//example.com:8042")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some("example.com"), port: Some(8042)),
|
|
))
|
|
uri.parse("foo:/:8042")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), path: "/:8042"),
|
|
))
|
|
uri.parse("foo://:8042")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some(""),
|
|
port: Some(8042),
|
|
),
|
|
))
|
|
uri.parse("foo://example.com:8042")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
port: Some(8042),
|
|
),
|
|
))
|
|
uri.parse(":8042") |> should.be_error
|
|
uri.parse("//:8042x") |> should.be_error
|
|
}),
|
|
it("undefined port", fn() {
|
|
uri.parse("/:")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "/:")))
|
|
uri.parse("//:")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some(""), port: None)))
|
|
uri.parse("//example.com:")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some("example.com"), port: None),
|
|
))
|
|
uri.parse("foo:/:")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), path: "/:"),
|
|
))
|
|
uri.parse("foo://:")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), host: Some(""), port: None),
|
|
))
|
|
uri.parse("foo://example.com:")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
port: None,
|
|
),
|
|
))
|
|
uri.parse(":") |> should.be_error
|
|
uri.parse("//:x") |> should.be_error
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_path_tests() {
|
|
describe("path parsing", [
|
|
it("simple parse", fn() {
|
|
uri.parse("over/there")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "over/there")))
|
|
uri.parse("/over/there")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "/over/there")))
|
|
uri.parse("foo:/over/there")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), path: "/over/there"),
|
|
))
|
|
uri.parse("foo://example.com/over/there")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
path: "/over/there",
|
|
),
|
|
))
|
|
uri.parse("foo://example.com:8042/over/there")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
port: Some(8042),
|
|
path: "/over/there",
|
|
),
|
|
))
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_query_part_tests() {
|
|
describe("query parsing", [
|
|
it("simple parse", fn() {
|
|
uri.parse("foo:?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), query: Some("name=ferret")),
|
|
))
|
|
uri.parse("foo:over/there?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
path: "over/there",
|
|
query: Some("name=ferret"),
|
|
),
|
|
))
|
|
uri.parse("foo:/over/there?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
path: "/over/there",
|
|
query: Some("name=ferret"),
|
|
),
|
|
))
|
|
uri.parse("foo://example.com?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
query: Some("name=ferret"),
|
|
),
|
|
))
|
|
uri.parse("foo://example.com/?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
path: "/",
|
|
query: Some("name=ferret"),
|
|
),
|
|
))
|
|
|
|
uri.parse("?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "", query: Some("name=ferret")),
|
|
))
|
|
uri.parse("over/there?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "over/there", query: Some("name=ferret")),
|
|
))
|
|
uri.parse("/?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "/", query: Some("name=ferret")),
|
|
))
|
|
uri.parse("/over/there?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "/over/there", query: Some("name=ferret")),
|
|
))
|
|
uri.parse("//example.com?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("example.com"),
|
|
query: Some("name=ferret"),
|
|
),
|
|
))
|
|
uri.parse("//example.com/?name=ferret")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("example.com"),
|
|
path: "/",
|
|
query: Some("name=ferret"),
|
|
),
|
|
))
|
|
}),
|
|
it("percent encoding", fn() {
|
|
uri.parse("foo://example.com/?name=%E5%90%88%E6%B0%97%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
path: "/",
|
|
query: Some("name=%E5%90%88%E6%B0%97%E9%81%93"),
|
|
),
|
|
))
|
|
uri.parse("//example.com/?name=%E5%90%88%E6%B0%97%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("example.com"),
|
|
path: "/",
|
|
query: Some("name=%E5%90%88%E6%B0%97%E9%81%93"),
|
|
),
|
|
))
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_fragment_tests() {
|
|
describe("fragment parsing", [
|
|
it("simple parse", fn() {
|
|
uri.parse("foo:#nose")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, scheme: Some("foo"), fragment: Some("nose")),
|
|
))
|
|
uri.parse("foo:over/there#nose")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
path: "over/there",
|
|
fragment: Some("nose"),
|
|
),
|
|
))
|
|
uri.parse("foo:/over/there#nose")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
path: "/over/there",
|
|
fragment: Some("nose"),
|
|
),
|
|
))
|
|
uri.parse("foo://example.com#nose")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
fragment: Some("nose"),
|
|
),
|
|
))
|
|
uri.parse("foo://example.com/#nose")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
path: "/",
|
|
fragment: Some("nose"),
|
|
),
|
|
))
|
|
uri.parse("foo://example.com#nose")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
fragment: Some("nose"),
|
|
),
|
|
))
|
|
|
|
uri.parse("#nose")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, fragment: Some("nose"))))
|
|
uri.parse("over/there#nose")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "over/there", fragment: Some("nose")),
|
|
))
|
|
uri.parse("/#nose")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "/", fragment: Some("nose")),
|
|
))
|
|
uri.parse("/over/there#nose")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, path: "/over/there", fragment: Some("nose")),
|
|
))
|
|
uri.parse("//example.com#nose")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("example.com"),
|
|
fragment: Some("nose"),
|
|
),
|
|
))
|
|
uri.parse("//example.com/#nose")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("example.com"),
|
|
path: "/",
|
|
fragment: Some("nose"),
|
|
),
|
|
))
|
|
}),
|
|
it("percent encoding", fn() {
|
|
uri.parse("foo://example.com#%E5%90%88%E6%B0%97%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some("example.com"),
|
|
fragment: Some("%E5%90%88%E6%B0%97%E9%81%93"),
|
|
),
|
|
))
|
|
uri.parse("//example.com/#%E5%90%88%E6%B0%97%E9%81%93")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("example.com"),
|
|
path: "/",
|
|
fragment: Some("%E5%90%88%E6%B0%97%E9%81%93"),
|
|
),
|
|
))
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_special_tests() {
|
|
describe("special parsing", [
|
|
it("special 1", fn() {
|
|
uri.parse("//?")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some(""), query: Some("")),
|
|
))
|
|
uri.parse("//#")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some(""), fragment: Some("")),
|
|
))
|
|
uri.parse("//?#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some(""),
|
|
query: Some(""),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("foo://?")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some(""),
|
|
query: Some(""),
|
|
),
|
|
))
|
|
uri.parse("foo://#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some(""),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("foo://?#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some(""),
|
|
query: Some(""),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("///")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some(""), path: "/")))
|
|
uri.parse("///hostname")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some(""), path: "/hostname"),
|
|
))
|
|
uri.parse("///?")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some(""), path: "/", query: Some("")),
|
|
))
|
|
uri.parse("///#")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some(""), path: "/", fragment: Some("")),
|
|
))
|
|
uri.parse("///?#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some(""),
|
|
path: "/",
|
|
query: Some(""),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("//foo?")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some("foo"), query: Some("")),
|
|
))
|
|
uri.parse("//foo#")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some("foo"), fragment: Some("")),
|
|
))
|
|
uri.parse("//foo?#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
host: Some("foo"),
|
|
query: Some(""),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("//foo/")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some("foo"), path: "/")))
|
|
uri.parse("http://foo?")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("foo"),
|
|
query: Some(""),
|
|
),
|
|
))
|
|
uri.parse("http://foo#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("foo"),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("http://foo?#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("foo"),
|
|
query: Some(""),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("http://foo/")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("foo"),
|
|
path: "/",
|
|
),
|
|
))
|
|
uri.parse("http://foo:80?")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("foo"),
|
|
port: Some(80),
|
|
query: Some(""),
|
|
),
|
|
))
|
|
uri.parse("http://foo:80#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("foo"),
|
|
port: Some(80),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("http://foo:80?#")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("foo"),
|
|
port: Some(80),
|
|
query: Some(""),
|
|
fragment: Some(""),
|
|
),
|
|
))
|
|
uri.parse("http://foo:80/")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("foo"),
|
|
port: Some(80),
|
|
path: "/",
|
|
),
|
|
))
|
|
uri.parse("?")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "", query: Some(""))))
|
|
uri.parse("??")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "", query: Some("?"))))
|
|
uri.parse("???")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "", query: Some("??"))))
|
|
uri.parse("#")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, path: "", fragment: Some(""))))
|
|
uri.parse("##")
|
|
|> should.be_error
|
|
uri.parse("###")
|
|
|> should.be_error
|
|
}),
|
|
it("special 2", fn() {
|
|
uri.parse("a://:1/")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("a"),
|
|
host: Some(""),
|
|
port: Some(1),
|
|
path: "/",
|
|
),
|
|
))
|
|
uri.parse("a:/a/")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, scheme: Some("a"), path: "/a/")))
|
|
uri.parse("//@")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some(""), path: "", userinfo: Some("")),
|
|
))
|
|
uri.parse("foo://@")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some(""),
|
|
path: "",
|
|
userinfo: Some(""),
|
|
),
|
|
))
|
|
uri.parse("//@/")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some(""), path: "/", userinfo: Some("")),
|
|
))
|
|
uri.parse("foo://@/")
|
|
|> should.equal(Ok(
|
|
Uri(
|
|
..types.empty_uri,
|
|
scheme: Some("foo"),
|
|
host: Some(""),
|
|
path: "/",
|
|
userinfo: Some(""),
|
|
),
|
|
))
|
|
uri.parse("//localhost:/")
|
|
|> should.equal(Ok(
|
|
Uri(..types.empty_uri, host: Some("localhost"), path: "/"),
|
|
))
|
|
uri.parse("//:")
|
|
|> should.equal(Ok(Uri(..types.empty_uri, host: Some(""), path: "")))
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_failure_tests() {
|
|
describe("fail parsing", [
|
|
it("failure", fn() {
|
|
uri.parse("å") |> should.be_error
|
|
uri.parse("aå:/foo") |> should.be_error
|
|
uri.parse("foo://usär@host") |> should.be_error
|
|
uri.parse("//host/path?foö=bar") |> should.be_error
|
|
uri.parse("//host/path#foö") |> should.be_error
|
|
uri.parse("//[:::127.0.0.1]") |> should.be_error
|
|
uri.parse("//localhost:A8") |> should.be_error
|
|
uri.parse("http://f%ff%%ff/") |> should.be_error
|
|
uri.parse("http://f%ff%fr/") |> should.be_error
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn merge_tests() {
|
|
describe("merging", [
|
|
it("relative merge", fn() {
|
|
let uri1 = uri.parse("/relative") |> should.be_ok
|
|
let uri2 = uri.parse("") |> should.be_ok
|
|
uri.merge(uri1, uri2) |> should.be_error
|
|
}),
|
|
it("simple merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl") |> should.be_ok
|
|
let uri2 = uri.parse("http://example.com/baz") |> should.be_ok
|
|
uri.merge(uri1, uri2) |> should.equal(uri.parse("http://example.com/baz"))
|
|
}),
|
|
it("segments merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl") |> should.be_ok
|
|
let uri2 =
|
|
uri.parse("http://example.com/.././bob/../../baz") |> should.be_ok
|
|
uri.merge(uri1, uri2) |> should.equal(uri.parse("http://example.com/baz"))
|
|
}),
|
|
it("base with authority merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl") |> should.be_ok
|
|
let uri2 = uri.parse("//example.com/baz") |> should.be_ok
|
|
uri.merge(uri1, uri2) |> should.equal(uri.parse("http://example.com/baz"))
|
|
}),
|
|
it("base with authority segments merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl") |> should.be_ok
|
|
let uri2 =
|
|
uri.parse("//example.com/.././bob/../../../baz") |> should.be_ok
|
|
uri.merge(uri1, uri2) |> should.equal(uri.parse("http://example.com/baz"))
|
|
}),
|
|
it("base with absolute merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl/eh") |> should.be_ok
|
|
let uri2 = uri.parse("/baz") |> should.be_ok
|
|
uri.merge(uri1, uri2) |> should.equal(uri.parse("http://google.com/baz"))
|
|
}),
|
|
it("base with relative merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl/eh") |> should.be_ok
|
|
let uri2 = uri.parse("baz") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/weebl/baz"))
|
|
let uri1 = uri.parse("http://google.com/weebl/") |> should.be_ok
|
|
let uri2 = uri.parse("baz") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/weebl/baz"))
|
|
let uri1 = uri.parse("http://google.com") |> should.be_ok
|
|
let uri2 = uri.parse("baz") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/baz"))
|
|
}),
|
|
it("base with relative segments merge", fn() {
|
|
let uri1 = uri.parse("http://google.com") |> should.be_ok
|
|
let uri2 = uri.parse("/.././bob/../../../baz") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/baz"))
|
|
}),
|
|
it("base with empty uri merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl/bob") |> should.be_ok
|
|
let uri2 = uri.parse("") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/weebl/bob"))
|
|
}),
|
|
|
|
it("base with fragment merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl/bob") |> should.be_ok
|
|
let uri2 = uri.parse("#fragment") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/weebl/bob#fragment"))
|
|
}),
|
|
it("base with query merge", fn() {
|
|
let uri1 = uri.parse("http://google.com/weebl/bob") |> should.be_ok
|
|
let uri2 = uri.parse("?query") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/weebl/bob?query"))
|
|
let uri1 = uri.parse("http://google.com/weebl/bob?query1") |> should.be_ok
|
|
let uri2 = uri.parse("?query2") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/weebl/bob?query2"))
|
|
let uri1 = uri.parse("http://google.com/weebl/bob?query1") |> should.be_ok
|
|
let uri2 = uri.parse("") |> should.be_ok
|
|
uri.merge(uri1, uri2)
|
|
|> should.equal(uri.parse("http://google.com/weebl/bob?query1"))
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn more_merge_tests() {
|
|
describe("rfc merge tests", [
|
|
it("normal examples", fn() {
|
|
let base = uri.parse("http://a/b/c/d;p?q") |> should.be_ok
|
|
|
|
let rel = uri.parse("g:h") |> should.be_ok
|
|
uri.merge(base, rel) |> should.be_ok |> should.equal(rel)
|
|
let rel = uri.parse("g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g") |> should.be_ok)
|
|
let rel = uri.parse("./g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g") |> should.be_ok)
|
|
let rel = uri.parse("g/") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g/") |> should.be_ok)
|
|
let rel = uri.parse("/g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/g") |> should.be_ok)
|
|
let rel = uri.parse("//g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://g") |> should.be_ok)
|
|
let rel = uri.parse("?y") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/d;p?y") |> should.be_ok)
|
|
let rel = uri.parse("g?y") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g?y") |> should.be_ok)
|
|
let rel = uri.parse("#s") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/d;p?q#s") |> should.be_ok)
|
|
let rel = uri.parse("g#s") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g#s") |> should.be_ok)
|
|
let rel = uri.parse("g?y#s") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g?y#s") |> should.be_ok)
|
|
let rel = uri.parse(";x") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/;x") |> should.be_ok)
|
|
let rel = uri.parse("g;x") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g;x") |> should.be_ok)
|
|
let rel = uri.parse("g;x?y#s") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g;x?y#s") |> should.be_ok)
|
|
let rel = uri.parse("") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/d;p?q") |> should.be_ok)
|
|
let rel = uri.parse(".") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/") |> should.be_ok)
|
|
let rel = uri.parse("./") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/") |> should.be_ok)
|
|
let rel = uri.parse("..") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/") |> should.be_ok)
|
|
let rel = uri.parse("../") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/") |> should.be_ok)
|
|
let rel = uri.parse("../g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/g") |> should.be_ok)
|
|
let rel = uri.parse("../..") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/") |> should.be_ok)
|
|
let rel = uri.parse("../../") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/") |> should.be_ok)
|
|
let rel = uri.parse("../../g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/g") |> should.be_ok)
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn normalise_tests() {
|
|
describe("normalise", [
|
|
it("basic normalise", fn() {
|
|
uri.parse("/a/b/c/./../../g")
|
|
|> should.be_ok
|
|
|> uri.normalise
|
|
|> should.equal(Uri(..empty_uri, path: "/a/g"))
|
|
uri.parse("mid/content=5/../6")
|
|
|> should.be_ok
|
|
|> uri.normalise
|
|
|> should.equal(Uri(..empty_uri, path: "mid/6"))
|
|
}),
|
|
it("normalise ports", fn() {
|
|
uri.parse("http://example.com:80/test")
|
|
|> should.be_ok
|
|
|> uri.normalise
|
|
|> should.equal(
|
|
Uri(
|
|
..empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("example.com"),
|
|
path: "/test",
|
|
),
|
|
)
|
|
uri.parse("https://example.com:443/test")
|
|
|> should.be_ok
|
|
|> uri.normalise
|
|
|> should.equal(
|
|
Uri(
|
|
..empty_uri,
|
|
scheme: Some("https"),
|
|
host: Some("example.com"),
|
|
path: "/test",
|
|
),
|
|
)
|
|
uri.parse("http://example.com:8080/test")
|
|
|> should.be_ok
|
|
|> uri.normalise
|
|
|> should.equal(
|
|
Uri(
|
|
..empty_uri,
|
|
scheme: Some("http"),
|
|
host: Some("example.com"),
|
|
port: Some(8080),
|
|
path: "/test",
|
|
),
|
|
)
|
|
uri.parse("https://example.com:8043/test")
|
|
|> should.be_ok
|
|
|> uri.normalise
|
|
|> should.equal(
|
|
Uri(
|
|
..empty_uri,
|
|
scheme: Some("https"),
|
|
host: Some("example.com"),
|
|
port: Some(8043),
|
|
path: "/test",
|
|
),
|
|
)
|
|
}),
|
|
it("abnormal examples", fn() {
|
|
let base = uri.parse("http://a/b/c/d;p?q") |> should.be_ok
|
|
|
|
let rel = uri.parse("../../../g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/g") |> should.be_ok)
|
|
let rel = uri.parse("../../../../g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/g") |> should.be_ok)
|
|
let rel = uri.parse("/./g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/g") |> should.be_ok)
|
|
let rel = uri.parse("/../g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/g") |> should.be_ok)
|
|
let rel = uri.parse("g.") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g.") |> should.be_ok)
|
|
let rel = uri.parse(".g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/.g") |> should.be_ok)
|
|
let rel = uri.parse("g..") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g..") |> should.be_ok)
|
|
let rel = uri.parse("..g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/..g") |> should.be_ok)
|
|
}),
|
|
it("weird examples", fn() {
|
|
let base = uri.parse("http://a/b/c/d;p?q") |> should.be_ok
|
|
|
|
let rel = uri.parse("./../g") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/g") |> should.be_ok)
|
|
let rel = uri.parse("./g/.") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g/") |> should.be_ok)
|
|
let rel = uri.parse("g/./h") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g/h") |> should.be_ok)
|
|
let rel = uri.parse("g/../h") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/h") |> should.be_ok)
|
|
let rel = uri.parse("g;x=1/./y") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g;x=1/y") |> should.be_ok)
|
|
let rel = uri.parse("g;x=1/../y") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/y") |> should.be_ok)
|
|
}),
|
|
|
|
it("weird fragment examples", fn() {
|
|
let base = uri.parse("http://a/b/c/d;p?q") |> should.be_ok
|
|
|
|
let rel = uri.parse("g?y/./x") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g?y/./x") |> should.be_ok)
|
|
let rel = uri.parse("g?y/../x") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g?y/../x") |> should.be_ok)
|
|
let rel = uri.parse("g#s/./x") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g#s/./x") |> should.be_ok)
|
|
let rel = uri.parse("g#s/../x") |> should.be_ok
|
|
uri.merge(base, rel)
|
|
|> should.be_ok
|
|
|> should.equal(uri.parse("http://a/b/c/g#s/../x") |> should.be_ok)
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn to_string_tests() {
|
|
describe("to_string test", [
|
|
it("simple test", fn() {
|
|
let test_uri =
|
|
types.Uri(
|
|
Some("https"),
|
|
Some("weebl:bob"),
|
|
Some("example.com"),
|
|
Some(1234),
|
|
"/path",
|
|
Some("query=true"),
|
|
Some("fragment"),
|
|
)
|
|
uri.to_string(test_uri)
|
|
|> should.equal(
|
|
"https://weebl:bob@example.com:1234/path?query=true#fragment",
|
|
)
|
|
}),
|
|
it("path only", fn() {
|
|
types.Uri(..types.empty_uri, path: "/")
|
|
|> uri.to_string
|
|
|> should.equal("/")
|
|
types.Uri(..types.empty_uri, path: "/blah")
|
|
|> uri.to_string
|
|
|> should.equal("/blah")
|
|
types.Uri(..types.empty_uri, userinfo: Some("user"), path: "/blah")
|
|
|> uri.to_string
|
|
|> should.equal("/blah")
|
|
types.Uri(..types.empty_uri, path: "")
|
|
|> uri.to_string
|
|
|> should.equal("")
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn equivalence_tests() {
|
|
describe("equivalence tests", [
|
|
it("equal", fn() {
|
|
let uri1 = uri.parse("http://example.com") |> should.be_ok
|
|
let uri2 = uri.parse("HTTP://EXAMPLE.COM") |> should.be_ok
|
|
uri.are_equivalent(uri1, uri2) |> should.be_true
|
|
|
|
let uri1 = uri.parse("http://example.com") |> should.be_ok
|
|
let uri2 = uri.parse("HTTP://EX%41MPLE.COM") |> should.be_ok
|
|
uri.are_equivalent(uri1, uri2) |> should.be_true
|
|
|
|
let uri1 = uri.parse("http://example.com/a/b/c") |> should.be_ok
|
|
let uri2 = uri.parse("HTTP://EXaMPLE.COM/a/d/../b/e/../c") |> should.be_ok
|
|
uri.are_equivalent(uri1, uri2) |> should.be_true
|
|
|
|
let uri1 = uri.parse("http://example.com/a/b/c") |> should.be_ok
|
|
let uri2 =
|
|
uri.parse("HTTP://EXaMPLE.COM/a/../../../../a/b/e/../c")
|
|
|> should.be_ok
|
|
uri.are_equivalent(uri1, uri2) |> should.be_true
|
|
}),
|
|
])
|
|
}
|
|
|
|
const percent_codec_fixtures = [
|
|
#(" ", "%20"),
|
|
#(",", "%2C"),
|
|
#(";", "%3B"),
|
|
#(":", "%3A"),
|
|
#("!", "!"),
|
|
#("?", "%3F"),
|
|
#("'", "'"),
|
|
#("(", "("),
|
|
#(")", ")"),
|
|
#("[", "%5B"),
|
|
#("@", "%40"),
|
|
#("/", "%2F"),
|
|
#("\\", "%5C"),
|
|
#("&", "%26"),
|
|
#("#", "%23"),
|
|
#("=", "%3D"),
|
|
#("~", "~"),
|
|
#("ñ", "%C3%B1"),
|
|
#("-", "-"),
|
|
#("_", "_"),
|
|
#(".", "."),
|
|
#("*", "*"),
|
|
#("+", "+"),
|
|
#("100% great+fun", "100%25%20great+fun"),
|
|
]
|
|
|
|
pub fn percent_encode_tests() {
|
|
describe("percent encoding", [
|
|
it("encoding", fn() {
|
|
percent_codec_fixtures
|
|
|> list.map(fn(t) {
|
|
let #(a, b) = t
|
|
uri.percent_encode(a)
|
|
|> should.equal(b)
|
|
})
|
|
Nil
|
|
}),
|
|
it("decoding", fn() {
|
|
percent_codec_fixtures
|
|
|> list.map(fn(t) {
|
|
let #(a, b) = t
|
|
uri.percent_decode(b)
|
|
|> should.equal(Ok(a))
|
|
})
|
|
Nil
|
|
}),
|
|
it("fail decoding", fn() {
|
|
uri.percent_decode("%C3test") |> should.be_error
|
|
uri.percent_decode("%C3%01test") |> should.be_error
|
|
uri.percent_decode("%E2%82%01test") |> should.be_error
|
|
uri.percent_decode("%E2%01%ACtest") |> should.be_error
|
|
uri.percent_decode("%F0%90%80%01test") |> should.be_error
|
|
uri.percent_decode("%F0%90%01%85test") |> should.be_error
|
|
uri.percent_decode("%F0%01%80%85test") |> should.be_error
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn parse_query_tests() {
|
|
describe("parse_query", [
|
|
it("basic parse", fn() {
|
|
uri.parse_query("el1=123&el2=321")
|
|
|> should.be_ok
|
|
|> should.equal([#("el1", "123"), #("el2", "321")])
|
|
uri.parse_query("el%201=123&el+2=321")
|
|
|> should.be_ok
|
|
|> should.equal([#("el 1", "123"), #("el 2", "321")])
|
|
uri.parse_query("el%E2%82%AC1=12%CE%A33&el%F0%90%80%852=321")
|
|
|> should.be_ok
|
|
|> should.equal([#("el€1", "12Σ3"), #("el𐀅2", "321")])
|
|
}),
|
|
it("empty parts", fn() {
|
|
uri.parse_query("el1=123&&el2=321")
|
|
|> should.be_ok
|
|
|> should.equal([#("el1", "123"), #("el2", "321")])
|
|
uri.parse_query("el1=&el2=")
|
|
|> should.be_ok
|
|
|> should.equal([#("el1", ""), #("el2", "")])
|
|
uri.parse_query("")
|
|
|> should.be_ok
|
|
|> should.equal([])
|
|
uri.parse_query("=123&el2=321")
|
|
|> should.be_ok
|
|
|> should.equal([#("", "123"), #("el2", "321")])
|
|
uri.parse_query("=&el2=321")
|
|
|> should.be_ok
|
|
|> should.equal([#("", ""), #("el2", "321")])
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn query_to_string_tests() {
|
|
describe("query_to_string", [
|
|
it("basic query", fn() {
|
|
uri.query_to_string([#("el1", "123"), #("el2", "321")])
|
|
|> should.equal("el1=123&el2=321")
|
|
uri.query_to_string([#("el 1", "123"), #("el 2", "321")])
|
|
|> should.equal("el%201=123&el%202=321")
|
|
uri.query_to_string([#("el€1", "12Σ3"), #("el𐀅2", "321")])
|
|
|> should.equal("el%E2%82%AC1=12%CE%A33&el%F0%90%80%852=321")
|
|
}),
|
|
it("empty parts", fn() {
|
|
uri.query_to_string([#("el1", ""), #("el2", "")])
|
|
|> should.equal("el1=&el2=")
|
|
uri.query_to_string([])
|
|
|> should.equal("")
|
|
uri.query_to_string([#("", "123"), #("el2", "321")])
|
|
|> should.equal("=123&el2=321")
|
|
uri.query_to_string([#("", ""), #("el2", "321")])
|
|
|> should.equal("=&el2=321")
|
|
}),
|
|
])
|
|
}
|
|
|
|
pub fn origin_tests() {
|
|
describe("origin", [
|
|
it("basic origin", fn() {
|
|
uri.parse("http://")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("http://")
|
|
uri.parse("http://example.com/test")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("http://example.com")
|
|
uri.parse("http://example.com:8080/test")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("http://example.com:8080")
|
|
uri.parse("http://example.com:80/test")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("http://example.com")
|
|
uri.parse("https://example.com:443/test")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("https://example.com")
|
|
uri.parse("http://example.com:443/test")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("http://example.com:443")
|
|
uri.parse("https://")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("https://")
|
|
uri.parse("http://example.com?query=no")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("http://example.com")
|
|
uri.parse("http:///nohost")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_ok
|
|
|> should.equal("http://")
|
|
}),
|
|
it("errors", fn() {
|
|
uri.parse("/nohost")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_error
|
|
uri.parse("file:///unknown/nohost")
|
|
|> should.be_ok
|
|
|> uri.origin
|
|
|> should.be_error
|
|
}),
|
|
])
|
|
}
|
|
// gleeunit test functions end in `_test`
|
|
// pub fn uri_test() {
|
|
// match("uri:")
|
|
// match("//@")
|
|
// match("//")
|
|
// match("")
|
|
// match("?")
|
|
// match("#")
|
|
// match("#\t")
|
|
// match("//:")
|
|
// }
|
|
|
|
// fn match(uri: String) {
|
|
// assert uri.parse(uri) |> uri.to_uri
|
|
// == uri2.parse(uri)
|
|
// }
|