path: root/tests/zotapi.rs

// zotapi - Rust wrapper for Sot API as implemented by Hubzilla
// Copyright (C) 2018  Harald Eilertsen <haraldei@anduin.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

extern crate zotapi;
extern crate mockito;

use mockito::{mock, Matcher};

#[test]
fn get_channel_stream() {
    let m = mock("GET", "/api/z/1.0/channel/stream")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let data = z.channel_stream();
    m.assert();
    assert_eq!(data.unwrap(), "{}");
}

#[test]
fn get_network_stream() {
    let m = mock("GET", "/api/z/1.0/network/stream")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let data = z.network_stream();
    m.assert();
    assert_eq!(data.unwrap(), "{}");
}

#[test]
fn return_error_if_invalid_auth_provided() {
    let m = mock("GET", "/api/z/1.0/channel/stream")
        .with_status(401)
        .with_header("content-type", "text")
        .with_body("This api requires login")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "nouser", "wrongpassword");
    let data = z.channel_stream();
    m.assert();
    assert!(data.is_err());
    assert_eq!(format!("{:?}", data), "Err(Unauthorized)");
}

#[test]
fn create_new_post() {
    let m = mock("POST", "/api/z/1.0/item/update")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .match_body("body=This+is+a+test")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.item().body("This is a test").create();

    m.assert();
}

#[test]
fn create_new_post_with_title() {
    // Note this regex is not as good as it could be. But since the rust regex crate
    // don't support back references it's the best we can do and not care about the
    // oder of the entries.
    let expected_body = Matcher::Regex(r"(title=A\+title&?|body=This\+is\+a\+test&?){2}".into());

    let m = mock("POST", "/api/z/1.0/item/update")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .match_body(expected_body)
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.item().title("A title").body("This is a test").create();

    m.assert();
}

#[test]
fn upload_item_with_media_file() {
    let m = mock("POST", "/api/z/1.0/item/update")
        .match_header("authorization", Matcher::Regex(r"Basic \w+=".into()))
        .match_header("content-type", Matcher::Regex("^multipart/form-data; boundary=.+$".into()))
        .match_body(Matcher::Regex(
            "--.+\r\n".to_owned() +
            "Content-Disposition: form-data; name=\"body\"\r\n" +
            "\r\nThis is a test\r\n" +
            "--.+\r\n" +
            "Content-Disposition: form-data; name=\"title\"\r\n" +
            "\r\nA title\r\n" +
            "--.+\r\n" +
            "Content-Disposition: form-data; name=\"files\"; filename=\"testfile.txt\"\r\n" +
            "Content-Type: text/plain\r\n" +
            "\r\ntestfile contents\n" +
            "\r\n--.+--\r\n"))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.item()
        .title("A title")
        .body("This is a test")
        .file("tests/fixtures/testfile.txt")
        .create();

    m.assert();
}

#[test]
fn upload_item_with_two_files() {
    let m = mock("POST", "/api/z/1.0/item/update")
        .match_header("authorization", Matcher::Regex(r"Basic \w+=".into()))
        .match_header("content-type", Matcher::Regex("^multipart/form-data; boundary=.+$".into()))
        .match_body(Matcher::Regex(
            "--.+\r\n".to_owned() +
            "Content-Disposition: form-data; name=\"body\"\r\n" +
            "\r\nThis is a test\r\n" +
            "--.+\r\n" +
            "Content-Disposition: form-data; name=\"title\"\r\n" +
            "\r\nA title\r\n" +
            "--.+\r\n" +
            "Content-Disposition: form-data; name=\"files\"; filename=\"testfile.txt\"\r\n" +
            "Content-Type: text/plain\r\n" +
            "\r\ntestfile contents\n" +
            "\r\n--.+\r\n" +
            "Content-Disposition: form-data; name=\"files\"; filename=\"testfile.txt\"\r\n" +
            "Content-Type: text/plain\r\n" +
            "\r\ntestfile contents\n" +
            "\r\n--.+--\r\n"))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.item()
        .title("A title")
        .body("This is a test")
        .file("tests/fixtures/testfile.txt")
        .file("tests/fixtures/testfile.txt")
        .create();

    m.assert();
}

#[test]
fn fetch_xchan_by_address() {
    let m = mock("GET", "/api/z/1.0/xchan?address=test%40test.com")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.xchan().by_address("test@test.com").fetch().unwrap();
    m.assert();
}

#[test]
fn fetch_xchan_by_hash() {
    let m = mock("GET", "/api/z/1.0/xchan?hash=baffebaff")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.xchan().by_hash("baffebaff").fetch().unwrap();
    m.assert();
}

#[test]
fn fetch_xchan_by_guid() {
    let m = mock("GET", "/api/z/1.0/xchan?guid=baffebaff-baff-baff")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.xchan().by_guid("baffebaff-baff-baff").fetch().unwrap();
    m.assert();
}

#[test]
fn fetch_connections() {
    let m = mock("GET", "/api/z/1.0/abook")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.abook().fetch().unwrap();
    m.assert();
}

#[test]
fn fetch_abconfig() {
    let m = mock("GET", "/api/z/1.0/abconfig")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.abconfig().fetch().unwrap();
    m.assert();
}

#[test]
fn fetch_privacy_groups() {
    let m = mock("GET", "/api/z/1.0/group")
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.group().fetch().unwrap();
    m.assert();
}

#[test]
fn fetch_members_of_group_by_group_id() {
    let m = mock("GET", Matcher::Regex(
            r"^/api/z/1.0/group_members\?([^&]*&)*group_id=42".into()))
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.group_members().by_group_id(42).fetch().unwrap();
    m.assert();
}

#[test]
fn fetch_members_of_group_by_group_name() {
    let m = mock("GET", Matcher::Regex(
            r"^/api/z/1.0/group_members\?([^&]*&)*group_name=Friends\+of\+pain".into()))
        .match_header("Authorization", Matcher::Regex(r"Basic \w+".into()))
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("{}")
        .create();

    let z = zotapi::client(&format!("http://{}", mockito::SERVER_ADDRESS), "testuser", "test1234");
    let _res = z.group_members().by_group_name("Friends of pain").fetch().unwrap();
    m.assert();
}