use assert

1 files changed, 46 insertions, 46 deletions

diff --git a/test/gleam/uri_test.gleam b/test/gleam/uri_test.gleam
index 3e638fd..1fbde75 100644
--- a/test/gleam/uri_test.gleam
+++ b/test/gleam/uri_test.gleam
@@ -3,7 +3,7 @@ import gleam/should
 import gleam/option.{Option, Some, None}
 
 pub fn full_parse_test() {
-  let Ok(
+  assert Ok(
     parsed,
   ) = uri.parse("https://foo:bar@example.com:1234/path?query=true#fragment")
   should.equal(parsed.scheme, Some("https"))
@@ -16,7 +16,7 @@ pub fn full_parse_test() {
 }
 
 pub fn parse_only_path_test() {
-  let Ok(parsed) = uri.parse("")
+  assert Ok(parsed) = uri.parse("")
   should.equal(parsed.scheme, None)
   should.equal(parsed.userinfo, None)
   should.equal(parsed.host, None)
@@ -27,7 +27,7 @@ pub fn parse_only_path_test() {
 }
 
 pub fn parse_only_host_test() {
-  let Ok(parsed) = uri.parse("//")
+  assert Ok(parsed) = uri.parse("//")
   should.equal(parsed.scheme, None)
   should.equal(parsed.userinfo, None)
   should.equal(parsed.host, Some(""))
@@ -42,7 +42,7 @@ pub fn error_parsing_uri_test() {
 }
 
 pub fn full_uri_to_string_test() {
-  let test_uri = uri.Uri(
+  assert test_uri = uri.Uri(
     Some("https"),
     Some("foo:bar"),
     Some("example.com"),
@@ -58,17 +58,17 @@ pub fn full_uri_to_string_test() {
 }
 
 pub fn path_only_uri_to_string_test() {
-  let test_uri = uri.Uri(None, None, None, None, "/", None, None)
+  assert test_uri = uri.Uri(None, None, None, None, "/", None, None)
   should.equal(uri.to_string(test_uri), "/")
 }
 
 pub fn parse_query_string_test() {
-  let Ok(parsed) = uri.parse_query("foo+bar=1&city=%C3%B6rebro")
+  assert Ok(parsed) = uri.parse_query("foo+bar=1&city=%C3%B6rebro")
   should.equal(parsed, [tuple("foo bar", "1"), tuple("city", "örebro")])
 }
 
 pub fn parse_empty_query_string_test() {
-  let Ok(parsed) = uri.parse_query("")
+  assert Ok(parsed) = uri.parse_query("")
   should.equal(parsed, [])
 }
 
@@ -77,14 +77,14 @@ pub fn error_parsing_query_test() {
 }
 
 pub fn query_to_string_test() {
-  let query_string = uri.query_to_string(
+  assert query_string = uri.query_to_string(
     [tuple("foo bar", "1"), tuple("city", "örebro")],
   )
   should.equal(query_string, "foo+bar=1&city=%C3%B6rebro")
 }
 
 pub fn empty_query_to_string_test() {
-  let query_string = uri.query_to_string([])
+  assert query_string = uri.query_to_string([])
   should.equal(query_string, "")
 }
 
@@ -103,108 +103,108 @@ pub fn parse_segments_test() {
 }
 
 pub fn origin_test() {
-  let Ok(parsed) = uri.parse("http://example.test/path?foo#bar")
+  assert Ok(parsed) = uri.parse("http://example.test/path?foo#bar")
   uri.origin(parsed)
   |> should.equal(Ok("http://example.test"))
 
-  let Ok(parsed) = uri.parse("http://example.test:8080")
+  assert Ok(parsed) = uri.parse("http://example.test:8080")
   uri.origin(parsed)
   |> should.equal(Ok("http://example.test:8080"))
 
-  let Ok(parsed) = uri.parse("https://example.test")
+  assert Ok(parsed) = uri.parse("https://example.test")
   uri.origin(parsed)
   |> should.equal(Ok("https://example.test"))
 
-  let Ok(parsed) = uri.parse("http:///path")
+  assert Ok(parsed) = uri.parse("http:///path")
   uri.origin(parsed)
   |> should.equal(Ok("http://"))
 
-  let Ok(parsed) = uri.parse("http://")
+  assert Ok(parsed) = uri.parse("http://")
   uri.origin(parsed)
   |> should.equal(Ok("http://"))
 
-  let Ok(parsed) = uri.parse("/path")
+  assert Ok(parsed) = uri.parse("/path")
   uri.origin(parsed)
   |> should.equal(Error(Nil))
 
-  let Ok(parsed) = uri.parse("file:///dev/null")
+  assert Ok(parsed) = uri.parse("file:///dev/null")
   uri.origin(parsed)
   |> should.equal(Error(Nil))
 }
 
 pub fn merge_test() {
-  let Ok(a) = uri.parse("/relative")
-  let Ok(b) = uri.parse("")
+  assert Ok(a) = uri.parse("/relative")
+  assert Ok(b) = uri.parse("")
   uri.merge(a, b)
   |> should.equal(Error(Nil))
 
-  let Ok(a) = uri.parse("http://google.com/foo")
-  let Ok(b) = uri.parse("http://example.com/baz")
+  assert Ok(a) = uri.parse("http://google.com/foo")
+  assert Ok(b) = uri.parse("http://example.com/baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/baz"))
 
-  let Ok(a) = uri.parse("http://google.com/foo")
-  let Ok(b) = uri.parse("http://example.com/.././bar/../../baz")
+  assert Ok(a) = uri.parse("http://google.com/foo")
+  assert Ok(b) = uri.parse("http://example.com/.././bar/../../baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/baz"))
 
-  let Ok(a) = uri.parse("http://google.com/foo")
-  let Ok(b) = uri.parse("//example.com/baz")
+  assert Ok(a) = uri.parse("http://google.com/foo")
+  assert Ok(b) = uri.parse("//example.com/baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/baz"))
 
-  let Ok(a) = uri.parse("http://google.com/foo")
-  let Ok(b) = uri.parse("//example.com/.././bar/../../../baz")
+  assert Ok(a) = uri.parse("http://google.com/foo")
+  assert Ok(b) = uri.parse("//example.com/.././bar/../../../baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/baz"))
 
-  let Ok(a) = uri.parse("http://example.com/foo/bar")
-  let Ok(b) = uri.parse("/baz")
+  assert Ok(a) = uri.parse("http://example.com/foo/bar")
+  assert Ok(b) = uri.parse("/baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/baz"))
 
-  let Ok(a) = uri.parse("http://example.com/foo/bar")
-  let Ok(b) = uri.parse("baz")
+  assert Ok(a) = uri.parse("http://example.com/foo/bar")
+  assert Ok(b) = uri.parse("baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/foo/baz"))
 
-  let Ok(a) = uri.parse("http://example.com/foo/")
-  let Ok(b) = uri.parse("baz")
+  assert Ok(a) = uri.parse("http://example.com/foo/")
+  assert Ok(b) = uri.parse("baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/foo/baz"))
 
-  let Ok(a) = uri.parse("http://example.com")
-  let Ok(b) = uri.parse("baz")
+  assert Ok(a) = uri.parse("http://example.com")
+  assert Ok(b) = uri.parse("baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/baz"))
 
-  let Ok(a) = uri.parse("http://example.com")
-  let Ok(b) = uri.parse("/.././bar/../../../baz")
+  assert Ok(a) = uri.parse("http://example.com")
+  assert Ok(b) = uri.parse("/.././bar/../../../baz")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/baz"))
 
-  let Ok(a) = uri.parse("http://example.com/foo/bar")
-  let Ok(b) = uri.parse("")
+  assert Ok(a) = uri.parse("http://example.com/foo/bar")
+  assert Ok(b) = uri.parse("")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/foo/bar"))
 
-  let Ok(a) = uri.parse("http://example.com/foo/bar")
-  let Ok(b) = uri.parse("#fragment")
+  assert Ok(a) = uri.parse("http://example.com/foo/bar")
+  assert Ok(b) = uri.parse("#fragment")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/foo/bar#fragment"))
 
-  let Ok(a) = uri.parse("http://example.com/foo/bar")
-  let Ok(b) = uri.parse("?query")
+  assert Ok(a) = uri.parse("http://example.com/foo/bar")
+  assert Ok(b) = uri.parse("?query")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/foo/bar?query"))
 
-  let Ok(a) = uri.parse("http://example.com/foo/bar?query1")
-  let Ok(b) = uri.parse("?query2")
+  assert Ok(a) = uri.parse("http://example.com/foo/bar?query1")
+  assert Ok(b) = uri.parse("?query2")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/foo/bar?query2"))
 
-  let Ok(a) = uri.parse("http://example.com/foo/bar?query")
-  let Ok(b) = uri.parse("")
+  assert Ok(a) = uri.parse("http://example.com/foo/bar?query")
+  assert Ok(b) = uri.parse("")
   uri.merge(a, b)
   |> should.equal(uri.parse("http://example.com/foo/bar?query"))
 }