shrupl/src/test_util/mock_ids.rs

use uuid::Uuid;

use crate::{
    Result,
    sharry::{AliasID, FileID, ShareID, Uri},
};

const VALID_URI: &str = "scheme://valid.uri";
const VALID_ALIAS: &str = "valid-alias";
const VALID_SHARE: &str = "valid-share";
const VALID_FILE: &str = "valid-file";

fn make_invalid(valid: &str) -> String {
    let invalid = valid.replace("valid", "invalid");

    assert_ne!(invalid, valid);

    invalid
}

fn make_valid(valid: &str) -> String {
    let invalid = make_invalid(valid);

    let valid = {
        let id = Uuid::now_v1(&[4, 8, 15, 16, 23, 42]);
        valid.replace("valid", &id.to_string())
    };

    assert_ne!(valid, invalid);

    valid
}

pub trait CheckID {
    fn check(self) -> Result<()>;
}

impl CheckID for (&Uri, &AliasID) {
    fn check(self) -> Result<()> {
        if self.0.to_string() == make_invalid(VALID_URI) {
            Err(self.0.into())
        } else if self.1.as_ref() == make_invalid(VALID_ALIAS) {
            Err(self.1.into())
        } else {
            Ok(())
        }
    }
}

impl CheckID for &ShareID {
    fn check(self) -> Result<()> {
        if self.to_string() == make_invalid(VALID_SHARE) {
            Err(self.into())
        } else {
            Ok(())
        }
    }
}

impl CheckID for (&ShareID, &FileID) {
    fn check(self) -> Result<()> {
        self.0.check()?;

        if self.1.to_string() == make_invalid(VALID_FILE) {
            Err(self.1.into())
        } else {
            Ok(())
        }
    }
}

impl From<bool> for Uri {
    fn from(value: bool) -> Self {
        if value {
            Self::from(make_valid(VALID_URI))
        } else {
            Self::from(make_invalid(VALID_URI))
        }
    }
}

impl From<bool> for AliasID {
    fn from(value: bool) -> Self {
        if value {
            Self::from(make_valid(VALID_ALIAS))
        } else {
            Self::from(make_invalid(VALID_ALIAS))
        }
    }
}

impl From<bool> for ShareID {
    fn from(value: bool) -> Self {
        if value {
            Self::from(make_valid(VALID_SHARE))
        } else {
            Self::from(make_invalid(VALID_SHARE))
        }
    }
}

impl From<bool> for FileID {
    fn from(value: bool) -> Self {
        if value {
            Self::new_test(make_valid(VALID_FILE))
        } else {
            Self::new_test(make_invalid(VALID_FILE))
        }
    }
}

#[test]
fn true_makes_valids() {
    let uri = Uri::from(true);
    let alias_id = AliasID::from(true);
    let share_id = ShareID::from(true);
    let file_id = FileID::from(true);

    assert!((&uri, &alias_id).check().is_ok());
    assert!(share_id.check().is_ok());
    assert!((&share_id, &file_id).check().is_ok());
}

#[test]
fn default_is_valid() {
    let uri = Uri::default();
    let alias_id = AliasID::from(true); // no `impl Default`
    let share_id = ShareID::default();
    let file_id = FileID::default();

    assert!((&uri, &alias_id).check().is_ok());
    assert!(share_id.check().is_ok());
    assert!((&share_id, &file_id).check().is_ok());
}

#[test]
fn false_makes_invalids() {
    use crate::Parameter;

    fn test_check(value: impl CheckID, callback: impl FnOnce(&Parameter) -> bool) {
        let check = value.check().unwrap_err();
        let p = check.get_invalid_param().unwrap();
        assert!(callback(p));
    }

    // valid ids
    let uri = Uri::from(true);
    let alias_id = AliasID::from(true);
    let share_id = ShareID::from(true);
    let file_id = FileID::from(true);

    // invalid ids
    let uri_i = Uri::from(false);
    let alias_id_i = AliasID::from(false);
    let share_id_i = ShareID::from(false);
    let file_id_i = FileID::from(false);

    // param checks
    let is_uri_i = |p: &Parameter| matches!(p, Parameter::Uri(_));
    let is_alias_id_i = |p: &Parameter| matches!(p, Parameter::AliasID(_));
    let is_share_id_i = |p: &Parameter| matches!(p, Parameter::ShareID(_));
    let is_file_id_i = |p: &Parameter| matches!(p, Parameter::FileID(_));

    // uri + alias
    test_check((&uri_i, &alias_id_i), is_uri_i);
    test_check((&uri_i, &alias_id), is_uri_i);
    test_check((&uri, &alias_id_i), is_alias_id_i);

    // share
    test_check(&share_id_i, is_share_id_i);

    // share + file
    test_check((&share_id_i, &file_id_i), is_share_id_i);
    test_check((&share_id_i, &file_id), is_share_id_i);
    test_check((&share_id, &file_id_i), is_file_id_i);
}