Add lightbug_http v0.1.19

recipes/lightbug_http/recipe.yaml

@@ -0,0 +1,54 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/prefix-dev/recipe-format/main/schema.json
+
+context:
+  version: "0.1.8"
+
+package:
+  name: "lightbug_http"
+  version: ${{ version }}
+
+source:
+  - git: https://github.com/saviorand/lightbug_http.git
+    rev: bcd2967c6177ac2c7800b0c4d51ddc0630326b28
+
+build:
+  number: 0
+  script:
+    - mkdir -p ${PREFIX}/lib/mojo
+    - magic run mojo package . -o ${PREFIX}/lib/mojo/lightbug_http.mojopkg
+
+requirements:
+  host:
+      - max
+  run:
+    - ${{ pin_compatible('max') }}
+    - small_time == 0.1.6
+
+tests:
+  - script:
+      - if: unix
+        then:
+          - magic run test
+    files:
+      recipe:
+        - tests/lightbug_http/io/test_bytes.mojo
+        - tests/lightbug_http/test_client.mojo
+        - tests/lightbug_http/test_cookie.mojo
+        - tests/lightbug_http/test_header.mojo
+        - tests/lightbug_http/test_http.mojo
+        - tests/lightbug_http/test_net.mojo
+        - tests/lightbug_http/test_uri.mojo
+
+about:
+  homepage: https://lightbug.site
+  license: MIT
+  license_file: LICENSE
+  summary: Lightbug is a simple and sweet HTTP framework for Mojo
+  repository: https://github.com/saviorand/lightbug_http
+
+extra:
+  maintainers:
+    - saviorand
+    - bgreni
+    - thatstoasty
+  project_name: lightbug_http

recipes/lightbug_http/tests/lightbug_http/io/test_bytes.mojo

@@ -0,0 +1,37 @@
+import testing
+from collections import Dict, List
+from lightbug_http.io.bytes import Bytes, bytes
+
+
+fn test_string_literal_to_bytes() raises:
+    var cases = Dict[StringLiteral, Bytes]()
+    cases[""] = Bytes()
+    cases["Hello world!"] = Bytes(
+        72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33
+    )
+    cases["\0"] = Bytes(0)
+    cases["\0\0\0\0"] = Bytes(0, 0, 0, 0)
+    cases["OK"] = Bytes(79, 75)
+    cases["HTTP/1.1 200 OK"] = Bytes(
+        72, 84, 84, 80, 47, 49, 46, 49, 32, 50, 48, 48, 32, 79, 75
+    )
+
+    for c in cases.items():
+        testing.assert_equal(Bytes(c[].key.as_bytes()), c[].value)
+
+
+fn test_string_to_bytes() raises:
+    var cases = Dict[String, Bytes]()
+    cases[String("")] = Bytes()
+    cases[String("Hello world!")] = Bytes(
+        72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33
+    )
+    cases[String("\0")] = Bytes(0)
+    cases[String("\0\0\0\0")] = Bytes(0, 0, 0, 0)
+    cases[String("OK")] = Bytes(79, 75)
+    cases[String("HTTP/1.1 200 OK")] = Bytes(
+        72, 84, 84, 80, 47, 49, 46, 49, 32, 50, 48, 48, 32, 79, 75
+    )
+
+    for c in cases.items():
+        testing.assert_equal(Bytes(c[].key.as_bytes()), c[].value)

recipes/lightbug_http/tests/lightbug_http/test_client.mojo

@@ -0,0 +1,93 @@
+import testing
+from lightbug_http.client import Client
+from lightbug_http.http import HTTPRequest, encode
+from lightbug_http.uri import URI
+from lightbug_http.header import Header, Headers
+from lightbug_http.io.bytes import bytes
+
+
+fn test_mojo_client_redirect_external_req_google() raises:
+    var client = Client()
+    var req = HTTPRequest(
+        uri=URI.parse_raises("http://google.com"),
+        headers=Headers(
+            Header("Connection", "close")),
+        method="GET",
+    )
+    try:
+        var res = client.do(req)
+        testing.assert_equal(res.status_code, 200)
+    except e:
+        print(e)
+
+fn test_mojo_client_redirect_external_req_302() raises:
+    var client = Client()
+    var req = HTTPRequest(
+        uri=URI.parse_raises("http://httpbin.org/status/302"),
+        headers=Headers(
+            Header("Connection", "close")),
+        method="GET",
+    )
+    try:
+        var res = client.do(req)
+        testing.assert_equal(res.status_code, 200)
+    except e:
+        print(e)
+
+fn test_mojo_client_redirect_external_req_308() raises:
+    var client = Client()
+    var req = HTTPRequest(
+        uri=URI.parse_raises("http://httpbin.org/status/308"),
+        headers=Headers(
+            Header("Connection", "close")),
+        method="GET",
+    )
+    try:
+        var res = client.do(req)
+        testing.assert_equal(res.status_code, 200)
+    except e:
+        print(e)
+
+fn test_mojo_client_redirect_external_req_307() raises:
+    var client = Client()
+    var req = HTTPRequest(
+        uri=URI.parse_raises("http://httpbin.org/status/307"),
+        headers=Headers(
+            Header("Connection", "close")),
+        method="GET",
+    )
+    try:
+        var res = client.do(req)
+        testing.assert_equal(res.status_code, 200)
+    except e:
+        print(e)
+
+fn test_mojo_client_redirect_external_req_301() raises:
+    var client = Client()
+    var req = HTTPRequest(
+        uri=URI.parse_raises("http://httpbin.org/status/301"),
+        headers=Headers(
+            Header("Connection", "close")),
+        method="GET",
+    )
+    try:
+        var res = client.do(req)
+        testing.assert_equal(res.status_code, 200)
+        testing.assert_equal(res.headers.content_length(), 228)
+    except e:
+        print(e)
+
+fn test_mojo_client_lightbug_external_req_200() raises:
+    try:
+        var client = Client()
+        var req = HTTPRequest(
+            uri=URI.parse_raises("http://httpbin.org/status/200"),
+            headers=Headers(
+                Header("Connection", "close")),
+            method="GET",
+        )
+        var res = client.do(req)
+        testing.assert_equal(res.status_code, 200)
+    except e:
+        print(e)
+        raise

recipes/lightbug_http/tests/lightbug_http/test_cookie.mojo

@@ -0,0 +1,43 @@
+from lightbug_http.cookie import SameSite, Cookie, Duration, Expiration
+from small_time.small_time import SmallTime, now
+from testing import assert_true, assert_equal
+from collections import Optional
+
+fn test_set_cookie() raises:
+    cookie = Cookie(
+            name="mycookie",
+            value="myvalue",
+            max_age=Duration(minutes=20),
+            expires=Expiration.from_datetime(SmallTime(2037, 1, 22, 12, 0, 10, 0)),
+            path=str("/"),
+            domain=str("localhost"),
+            secure=True,
+            http_only=True,
+            same_site=SameSite.none,
+            partitioned=False
+    )
+    var header = cookie.to_header()
+    var header_value = header.value
+    var expected = "mycookie=myvalue; Expires=Thu, 22 Jan 2037 12:00:10 GMT; Max-Age=1200; Domain=localhost; Path=/; Secure; HttpOnly; SameSite=none"
+    assert_equal("set-cookie", header.key)
+    assert_equal(header_value, expected)
+
+
+fn test_set_cookie_partial_arguments() raises:
+    cookie = Cookie(
+            name="mycookie",
+            value="myvalue",
+            same_site=SameSite.lax
+    )
+    var header = cookie.to_header()
+    var header_value = header.value
+    var expected = "mycookie=myvalue; SameSite=lax"
+    assert_equal("set-cookie", header.key)
+    assert_equal( header_value, expected)
+
+
+fn test_expires_http_timestamp_format() raises:
+    var expected = "Thu, 22 Jan 2037 12:00:10 GMT"
+    var http_date = Expiration.from_datetime(SmallTime(2037, 1, 22, 12, 0, 10, 0)).http_date_timestamp()
+    assert_true(http_date is not None, msg="Http date is None")
+    assert_equal(expected , http_date.value())

recipes/lightbug_http/tests/lightbug_http/test_header.mojo

@@ -0,0 +1,56 @@
+from testing import assert_equal, assert_true
+from memory import Span
+from lightbug_http.utils import ByteReader
+from lightbug_http.header import Headers, Header
+from lightbug_http.io.bytes import Bytes, bytes
+
+
+def test_header_case_insensitive():
+    var headers = Headers(Header("Host", "SomeHost"))
+    assert_true("host" in headers)
+    assert_true("HOST" in headers)
+    assert_true("hOST" in headers)
+    assert_equal(headers["Host"], "SomeHost")
+    assert_equal(headers["host"], "SomeHost")
+
+
+def test_parse_request_header():
+    var headers_str = bytes(
+        """GET /index.html HTTP/1.1\r\nHost:example.com\r\nUser-Agent: Mozilla/5.0\r\nContent-Type: text/html\r\nContent-Length: 1234\r\nConnection: close\r\nTrailer: end-of-message\r\n\r\n"""
+    )
+    var header = Headers()
+    var b = Bytes(headers_str)
+    var reader = ByteReader(Span(b))
+    var method: String
+    var protocol: String
+    var uri: String
+    var properties = header.parse_raw(reader)
+    method, uri, protocol = properties[0], properties[1], properties[2]
+    assert_equal(uri, "/index.html")
+    assert_equal(protocol, "HTTP/1.1")
+    assert_equal(method, "GET")
+    assert_equal(header["Host"], "example.com")
+    assert_equal(header["User-Agent"], "Mozilla/5.0")
+    assert_equal(header["Content-Type"], "text/html")
+    assert_equal(header["Content-Length"], "1234")
+    assert_equal(header["Connection"], "close")
+
+
+def test_parse_response_header():
+    var headers_str = "HTTP/1.1 200 OK\r\nServer: example.com\r\nUser-Agent: Mozilla/5.0\r\nContent-Type: text/html\r\nContent-Encoding: gzip\r\nContent-Length: 1234\r\nConnection: close\r\nTrailer: end-of-message\r\n\r\n"
+    var header = Headers()
+    var protocol: String
+    var status_code: String
+    var status_text: String
+    var reader = ByteReader(headers_str.as_bytes())
+    var properties = header.parse_raw(reader)
+    protocol, status_code, status_text = properties[0], properties[1], properties[2]
+    assert_equal(protocol, "HTTP/1.1")
+    assert_equal(status_code, "200")
+    assert_equal(status_text, "OK")
+    assert_equal(header["Server"], "example.com")
+    assert_equal(header["Content-Type"], "text/html")
+    assert_equal(header["Content-Encoding"], "gzip")
+    assert_equal(header["Content-Length"], "1234")
+    assert_equal(header["Connection"], "close")
+    assert_equal(header["Trailer"], "end-of-message")

recipes/lightbug_http/tests/lightbug_http/test_http.mojo

@@ -0,0 +1,98 @@
+import testing
+from testing import assert_true, assert_equal
+from collections import Dict, List
+from lightbug_http.io.bytes import Bytes, bytes
+from lightbug_http.http import HTTPRequest, HTTPResponse, encode, HttpVersion
+from lightbug_http.header import Header, Headers, HeaderKey
+from lightbug_http.cookie import Cookie, ResponseCookieJar, RequestCookieJar, Duration, ResponseCookieKey
+from lightbug_http.uri import URI
+from lightbug_http.strings import to_string
+
+alias default_server_conn_string = "http://localhost:8080"
+
+def test_encode_http_request():
+    var uri = URI.parse_raises(default_server_conn_string + "/foobar?baz")
+    var req = HTTPRequest(
+        uri,
+        body=String("Hello world!").as_bytes(),
+        cookies=RequestCookieJar(
+            Cookie(name="session_id", value="123", path=str("/"), secure=True, max_age=Duration(minutes=10)),
+            Cookie(name="token", value="abc", domain=str("localhost"), path=str("/api"), http_only=True)
+        ),
+        headers=Headers(Header("Connection", "keep-alive")),
+    )
+
+    var as_str = str(req)
+    var req_encoded = to_string(encode(req^))
+
+
+    var expected =
+        "GET /foobar?baz HTTP/1.1\r\n"
+        "connection: keep-alive\r\n"
+        "content-length: 12\r\n"
+        "host: localhost:8080\r\n"
+        "cookie: session_id=123; token=abc\r\n"
+        "\r\n"
+        "Hello world!"
+
+    testing.assert_equal(
+        req_encoded,
+        expected
+    )
+    testing.assert_equal(req_encoded, as_str)
+
+
+def test_encode_http_response():
+    var res = HTTPResponse(bytes("Hello, World!"))
+    res.headers[HeaderKey.DATE] = "2024-06-02T13:41:50.766880+00:00"
+
+    res.cookies = ResponseCookieJar(
+        Cookie(name="session_id", value="123", path=str("/api"), secure=True),
+        Cookie(name="session_id", value="abc", path=str("/"), secure=True, max_age=Duration(minutes=10)),
+        Cookie(name="token", value="123", domain=str("localhost"), path=str("/api"), http_only=True)
+    )
+    var as_str = str(res)
+    var res_encoded = to_string(encode(res^))
+    var expected_full =
+        "HTTP/1.1 200 OK\r\n"
+        "server: lightbug_http\r\n"
+        "content-type: application/octet-stream\r\n"
+        "connection: keep-alive\r\ncontent-length: 13\r\n"
+        "date: 2024-06-02T13:41:50.766880+00:00\r\n"
+        "set-cookie: session_id=123; Path=/api; Secure\r\n"
+        "set-cookie: session_id=abc; Max-Age=600; Path=/; Secure\r\n"
+        "set-cookie: token=123; Domain=localhost; Path=/api; HttpOnly\r\n"
+        "\r\n"
+        "Hello, World!"
+
+    testing.assert_equal(res_encoded, expected_full)
+    testing.assert_equal(res_encoded, as_str)
+
+def test_decoding_http_response():
+    var res = String(
+        "HTTP/1.1 200 OK\r\n"
+        "server: lightbug_http\r\n"
+        "content-type: application/octet-stream\r\n"
+        "connection: keep-alive\r\ncontent-length: 13\r\n"
+        "date: 2024-06-02T13:41:50.766880+00:00\r\n"
+        "set-cookie: session_id=123; Path=/; Secure\r\n"
+        "\r\n"
+        "Hello, World!"
+    ).as_bytes()
+
+    var response = HTTPResponse.from_bytes(res)
+    var expected_cookie_key = ResponseCookieKey("session_id", "", "/")
+
+    assert_equal(1, len(response.cookies))
+    assert_true(expected_cookie_key in response.cookies, msg="request should contain a session_id header")
+    var session_id = response.cookies.get(expected_cookie_key)
+    assert_true(session_id is not None)
+    assert_equal(session_id.value().path.value(), "/")
+    assert_equal(200, response.status_code)
+    assert_equal("OK", response.status_text)
+
+def test_http_version_parse():
+    var v1 = HttpVersion("HTTP/1.1")
+    testing.assert_equal(v1._v, 1)
+    var v2 = HttpVersion("HTTP/2")
+    testing.assert_equal(v2._v, 2)

recipes/lightbug_http/tests/lightbug_http/test_net.mojo

@@ -0,0 +1,7 @@
+def test_net():
+    test_split_host_port()
+
+
+def test_split_host_port():
+    # TODO: Implement this test
+    ...