Ihr Guide zum Schreiben von Modultests für Ihre Compute Anwendung in Rust

Woher wissen wir, ob unsere Edge-Anwendungen auch wirklich funktionieren? Ich bin beim Schreiben von Code immer ausgesprochen zuversichtlich. Manchmal stimmen meine überzogenen Erwartungen aber mit der Realität nicht überein, weshalb ich meinen Code teste.

Mit Compute von Fastly können Sie hochgradig skalierbare, global verteilte Anwendungen erstellen und Code auf der Edge ausführen. In diesem Blogpost beschäftigen wir uns mit der Programmierung von Modultests für eine Rust Anwendung mithilfe von Viceroy, einem Tool, mit dem Sie lokale Tests für Entwickler durchführen können, die mit Compute arbeiten.

Ausführen einer Anwendung

Zuerst installieren wir die Fastly CLI und Rust. Richten Sie in einem neuen Verzeichnis ein neues Rust Basic Starter Kit ein, das das Routing und einfache synthetische Antworten aufzeigt:

fastly compute init

Wählen Sie Rust als Sprache und das Default starter for Rust-Kit aus.

Durch diese Auswahl wird eine funktionierende Anwendung im Verzeichnis erstellt. Die zugrunde liegende Programmlogik befindet sich in src/main.rs.

Führen Sie folgenden Code aus, um einen Build auszulösen und diese Anwendung lokal auszuführen:

fastly compute serve
...
INFO: Listening on http://127.0.0.1:7676

Wenn Sie http://127.0.0.1:7676 aufrufen, sollte Ihnen eine nutzerfreundliche Seite mit einer Bestätigung angezeigt werden, dass alles funktioniert hat.

Testen der Anwendung

Der Code scheint zu funktionieren, aber wir benötigen noch ein paar Tests, um zu überprüfen, ob er auch richtig funktioniert.

Installieren wir also Viceroy, mit dem wir die Tests lokal ausführen können, und cargo-nextest, das die Tests für uns in einer eigenen Wasm Instanz ausführt und die Ergebnisse anschließend zusammenfasst. 

Fügen Sie folgenden Code zur .cargo/config Ihres Projekts hinzu:

[target.wasm32-wasi]
runner = "viceroy run -C fastly.toml -- "

Wir müssen die Hauptfunktion in src/main.rs wie folgt umschreiben, damit sie sich testen lässt:

fn main() -> Result<(), Error> {
    let ds_req = Request::from_client();
    let us_resp = handler(ds_req)?;
    us_resp.send_to_client();
    Ok(())
}

fn handler(req: Request) -> Result<Response, Error> {
...

Jetzt können wir unter Nutzung des fastly crate ein paar einfache Tests schreiben.

Wir können Tests in drei wichtigen Bereichen durchführen:

• der Programmlogik, die unerwartete Methoden ablehnt

• der Logik, die die synthetische Antwort zurückgibt

• der Logik, die den Statuscode 404 zurückgibt

Für jeden dieser Bereiche stellen wir eine Anfrage und prüfen den Antwort-Statuscode, den Inhaltstyp und den Body. Fügen Sie dazu folgende Funktionen am Ende der Datei ein:

#[test]
fn test_post() {
    let req = fastly::Request::post("http://example.com/");
    let resp = handler(req).expect("request succeeds");
    assert_eq!(resp.get_status(), StatusCode::METHOD_NOT_ALLOWED);
    assert_eq!(resp.get_content_type(), Some(mime::TEXT_PLAIN_UTF_8));
    assert_eq!(resp.into_body_str(), "This method is not allowed\n");
}

#[test]
fn test_homepage() {
    let req = fastly::Request::get("http://example.com/");
    let resp = handler(req).expect("request succeeds");
    assert_eq!(resp.get_status(), StatusCode::OK);
    assert_eq!(resp.get_content_type(), Some(mime::TEXT_HTML_UTF_8));
    assert!(resp.into_body_str().contains("Welcome to Compute@Edge"));
}

#[test]
fn test_missing() {
    let req = fastly::Request::get("http://example.com/missing");
    let resp = handler(req).expect("request succeeds");
    assert_eq!(resp.get_status(), StatusCode::OK);
    assert_eq!(resp.get_content_type(), Some(mime::TEXT_PLAIN_UTF_8));
    assert_eq!(
        resp.into_body_str(),
        "The page you requested could not be found\n"
    );
}

Zur Durchführung unserer Tests verwenden wir cargo nextest run. Wenn sich im Handler ein heimtückischer Fehler eingeschlichen hat, könnte dies zu einer Fehlermeldung wie dieser führen, die anzeigt, dass ein 404er-Statuscode erwartet wurde, stattdessen aber der Statuscode 200 übermittelt wurde:

cargo nextest run
...
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `404`,
 right: `200`', src/main.rs:122:5
   Canceling due to test failure: 0 tests still running
------------
     Summary [   3.125s] 5 tests run: 4 passed, 1 failed, 0 skipped
        FAIL [   3.122s] fastly-compute-project::bin/fastly-compute-project test_missing
error: test run failed

Bei unserem Handler liegen allerdings keine Fehler vor und alles funktioniert wie erwartet. Nach Ausführung der Tests erhalten wir eine positive Zusammenfassung:

cargo nextest run
...
    Starting 3 tests across 1 binary
        PASS [   1.596s] fastly-compute-project::bin/fastly-compute-project test_post
        PASS [   1.885s] fastly-compute-project::bin/fastly-compute-project test_homepage
        PASS [   1.900s] fastly-compute-project::bin/fastly-compute-project test_missing
------------
     Summary [   1.902s] 3 tests run: 3 passed, 0 skipped

Nächste Schritte

Nachdem Sie jetzt wissen, wie man Modultests für Compute Anwendungen in Rust durchführt, gehen Sie doch noch einen Schritt weiter. Ich empfehle Ihnen, komplizierte Programmlogik in kleine, testbare Funktionen zu unterteilen. Und wenn Sie sich selbst etwas beweisen wollen, können Sie Ihre Tests schreiben, bevor Sie die Funktion selbst programmiert haben. Viel Spaß beim Testen!  Wenn Sie unsere Serverless-Plattform noch nicht nutzen, können Sie Compute jetzt kostenlos testen.