minccino/src/meta/test.rs

use super::routes::*;
use crate::meta::CIMetadata;
use crate::rocket;
use crate::test::*;
use crate::types::MacAddr;
use crate::yui::routes::*;
use crate::yui::InstanceReq;
use crate::yui::InstanceResponse;
use rocket::http::{ContentType, Header, Status};
use rocket::local::blocking::Client;
use std::net::{Ipv6Addr, SocketAddr, SocketAddrV6};

#[test]
fn metadata_works() {
    let client = Client::tracked(rocket()).expect("valid rocket instance");

    let instance = InstanceReq {
        name: "first-test".to_owned(),
        mac_address: MacAddr(LLV6_MAC).to_string(),
        ssh_keys: None,
        user_data: None,
    };
    let response = client
        .post(uri!("/_yui/", new_instance()))
        .header(Header::new("x-api-key", SNAKEOIL_KEY))
        .remote(saddr6!(localhost))
        .json(&instance)
        .dispatch();
    assert_eq!(response.status(), Status::Ok);

    let inst = response
        .into_json::<InstanceResponse>()
        .expect("json in InstanceResponse format");
    let inst = inst.instances.unwrap()[0].clone();

    let metadata = client
        .get(uri!(metadata()))
        .remote(saddr6!(LLV6_IP))
        .dispatch();
    assert_eq!(metadata.status(), Status::Ok);

    let metadata = metadata
        .into_json::<CIMetadata>()
        .expect("json in form CIMetadata");

    assert_eq!(metadata.local_hostname, instance.name);

    let response = client
        .delete(uri!("/_yui/", delete_instance(inst.id)))
        .header(Header::new("x-api-key", SNAKEOIL_KEY))
        .remote(saddr6!(localhost))
        .dispatch();
    assert_eq!(response.status(), Status::Ok);
}

#[test]
fn metadata_defaults_apply() {
    const SNAKEOIL_SSHKEY: &str =
        "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJg6JbxdLaFpG0vnXHV0kNoz282vgjtJlcvGv5DUDKJj snakeoil";
    const INSTANCE_SSHKEY: &str = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIGPxtsgJzSNTQAsv0LV7usNOP8CBmCoqD8AkwZUvE01E instance-key";
    let client = Client::tracked(rocket()).expect("valid rocket instance");

    let keys = SNAKEOIL_SSHKEY.to_owned();

    let response = client
        .post(uri!("/_yui/", set_defaults("ssh_keys")))
        .header(ContentType::Plain)
        .header(Header::new("x-api-key", SNAKEOIL_KEY))
        .remote(saddr6!(localhost))
        .body(keys)
        .dispatch();

    assert_eq!(
        response.status(),
        Status::Ok,
        "Couldn't set defaults: (code {}) {:?}",
        response.status().code,
        response.into_string()
    );

    // create the first instance, with no ssh keys
    let instance = InstanceReq {
        name: "first-test".to_owned(),
        mac_address: LLV6_MACSTR.to_owned(),
        ssh_keys: None,
        user_data: None,
    };

    let response = client
        .post(uri!("/_yui/", new_instance()))
        .json(&instance)
        .header(Header::new("x-api-key", SNAKEOIL_KEY))
        .remote(saddr6!(localhost))
        .dispatch();

    assert_eq!(response.status(), Status::Ok);

    let response = client
        .get(uri!(metadata()))
        .remote(saddr6!(LLV6_IP))
        .dispatch();

    assert_eq!(response.status(), Status::Ok);

    let response = response
        .into_json::<CIMetadata>()
        .expect("should be instance metadata");

    let keys = response
        .public_keys
        .expect("should be a vec of SSH public keys");

    assert_eq!(keys.len(), 1);
    assert_eq!(keys[0], SNAKEOIL_SSHKEY);

    // new instance, with defined ssh keys
    let instance = InstanceReq {
        name: "second-test".to_owned(),
        mac_address: LLV6_MACSTR2.to_owned(),
        ssh_keys: Some(vec![INSTANCE_SSHKEY.to_owned()]),
        user_data: None,
    };

    let response = client
        .post(uri!("/_yui/", new_instance()))
        .json(&instance)
        .header(Header::new("x-api-key", SNAKEOIL_KEY))
        .remote(saddr6!(localhost))
        .dispatch();

    assert_eq!(response.status(), Status::Ok);

    let response = client
        .get(uri!(metadata()))
        .remote(saddr6!(LLV6_IP2))
        .dispatch();

    assert_eq!(response.status(), Status::Ok);

    let response = response
        .into_json::<CIMetadata>()
        .expect("should be instance metadata");

    let keys = response
        .public_keys
        .expect("should be a vec of SSH public keys");

    assert_eq!(keys[0], INSTANCE_SSHKEY);
}

#[test]
fn userdata_works() {
    let client = Client::tracked(rocket()).expect("valid rocket instance");

    // create instance
    let instance = InstanceReq {
        name: "first-test".to_owned(),
        mac_address: MacAddr(LLV6_MAC).to_string(),
        ssh_keys: None,
        user_data: Some(base64::encode(SPEEX)),
    };
    let response = client
        .post(uri!("/_yui/", new_instance()))
        .header(Header::new("x-api-key", SNAKEOIL_KEY))
        .remote(saddr6!(localhost))
        .json(&instance)
        .dispatch();
    assert_eq!(response.status(), Status::Ok);

    // get userdata
    let userdata = client
        .get(uri!(userdata()))
        .remote(saddr6!(LLV6_IP))
        .dispatch();

    assert_eq!(userdata.status(), Status::Ok);
    assert_eq!(userdata.into_string().unwrap(), SPEEX);

    // make sure only LLV6_IP can access it
    let bad_userdata = client
        .get(uri!(userdata()))
        .remote(saddr6!(LLV6_IP2))
        .dispatch();

    assert_eq!(bad_userdata.status(), Status::NotFound);
}