use crate::filesystem::FileHandle;
use crate::protocol::*;
use server_framework::{Decode, Encode};

#[test]
fn every_request_roundtrips() {
    let h = FileHandle::new(3);
    for req in [
        StorageRequest::Attach,
        StorageRequest::Open { path_len: 9 },
        StorageRequest::Read { handle: h, len: 100 },
        StorageRequest::Write { handle: h, len: 7 },
        StorageRequest::Close { handle: h },
        StorageRequest::FileSize { handle: h },
        StorageRequest::ListDir { path_len: 1 },
        StorageRequest::Create { path_len: 5 },
        StorageRequest::Delete { path_len: 5 },
        StorageRequest::Mkdir { path_len: 4 },
        StorageRequest::Grant {
            path_len: 4,
            write: true,
        },
        StorageRequest::Grant {
            path_len: 0,
            write: false,
        },
        StorageRequest::Release,
        StorageRequest::SetKey { half: 1, words: [7, 9] },
    ] {
        assert_eq!(StorageRequest::decode(req.encode()), Some(req));
    }
}

#[test]
fn every_response_roundtrips() {
    for resp in [
        StorageResponse::Attached { size: BUFFER_SIZE },
        StorageResponse::Handle(FileHandle::new(2)),
        StorageResponse::Data { bytes: 512 },
        StorageResponse::Written { bytes: 8 },
        StorageResponse::Ok,
        StorageResponse::DirEntries { count: 3 },
        StorageResponse::Size(4096),
        StorageResponse::NotFound,
        StorageResponse::Error,
        StorageResponse::ReadOnly,
        StorageResponse::NotAttached,
        StorageResponse::Granted,
        StorageResponse::Denied,
    ] {
        assert_eq!(StorageResponse::decode(resp.encode()), Some(resp));
    }
}

#[test]
fn handles_that_do_not_fit_are_rejected_not_truncated() {
    assert_eq!(StorageRequest::decode([2, 0x1_0003, 10, 0]), None);
    assert_eq!(StorageRequest::decode([4, usize::MAX, 0, 0]), None);
}

#[test]
fn unknown_opcodes_do_not_decode() {
    assert_eq!(StorageRequest::decode([99, 0, 0, 0]), None);
    assert_eq!(StorageRequest::decode([usize::MAX, 0, 0, 0]), None);
}

#[test]
fn wire_numbers_are_the_shared_ones() {
    use types::storage::{op, reply};
    assert_eq!(StorageRequest::Read { handle: FileHandle::new(0), len: 0 }.encode()[0], op::READ);
    assert_eq!(StorageResponse::ReadOnly.encode()[0], reply::READ_ONLY);
}