Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

4.5 KB
Raw Blame
use std::sync::{Arc, Mutex};

use ai_usage::{AiFeature, UsageAmount, UsageEvent};
use macro_user_id::user_id::MacroUserIdStr;
use serde_json::json;

use super::*;
use crate::domain::models::Evaluation;

struct FakeProvider {
    answers: Result<Vec<f32>, JevError>,
    seen: Mutex<Vec<(Value, Vec<String>)>>,
}

impl FakeProvider {
    fn answering(answers: &[f32]) -> Arc<Self> {
        Arc::new(Self {
            answers: Ok(answers.to_vec()),
            seen: Mutex::default(),
        })
    }

    fn failing(error: JevError) -> Arc<Self> {
        Arc::new(Self {
            answers: Err(error),
            seen: Mutex::default(),
        })
    }
}

impl JevProvider for Arc<FakeProvider> {
    fn model_id(&self) -> &'static str {
        "jev-test"
    }

    async fn evaluate(
        &self,
        input: &Value,
        questions: &[YesNoQuestion],
    ) -> Result<Evaluation, JevError> {
        self.seen.lock().unwrap().push((
            input.clone(),
            questions.iter().map(|q| q.as_str().to_owned()).collect(),
        ));
        let answers = self.answers.clone()?;
        Ok(Evaluation {
            probabilities: answers
                .iter()
                .map(|value| Probability::new(*value).unwrap())
                .collect(),
            input_tokens: 120,
            output_tokens: 4,
        })
    }
}

#[derive(Default)]
struct FakeRecorder(Mutex<Vec<UsageEvent>>);

impl UsageRecorder for FakeRecorder {
    fn record(&self, event: UsageEvent) {
        self.0.lock().unwrap().push(event);
    }
}

fn usage() -> UsageContext {
    UsageContext::new(
        AiFeature::Automation,
        MacroUserIdStr::try_from("macro|[email protected]".to_owned()).unwrap(),
    )
}

fn questions(texts: &[&str]) -> Vec<YesNoQuestion> {
    texts
        .iter()
        .map(|text| YesNoQuestion::try_from(*text).unwrap())
        .collect()
}

#[tokio::test]
async fn returns_answers_in_question_order_and_records_tokens() {
    let provider = FakeProvider::answering(&[0.9, 0.1]);
    let recorder = Arc::new(FakeRecorder::default());
    let classifier = JevClassifier::new(provider.clone(), recorder.clone());
    let input = json!({ "subject": "Invoice #42" });

    let answers = classifier
        .classify(usage(), &input, &questions(&["Invoice?", "Spam?"]))
        .await
        .unwrap();

    assert_eq!(
        answers.iter().map(|p| p.get()).collect::<Vec<_>>(),
        [0.9, 0.1]
    );
    assert_eq!(
        provider.seen.lock().unwrap().as_slice(),
        [(input, vec!["Invoice?".to_owned(), "Spam?".to_owned()])]
    );
    let events = recorder.0.lock().unwrap();
    assert_eq!(events.len(), 1);
    assert_eq!(events[0].feature, AiFeature::Automation);
    assert_eq!(events[0].model, "jev-test");
    assert!(matches!(
        events[0].amount,
        UsageAmount::Tokens {
            input: 120,
            output: 4,
            cache_read: 0,
            cache_write: 0,
        }
    ));
}

#[tokio::test]
async fn rejects_empty_and_oversized_question_lists_without_calling_the_provider() {
    let provider = FakeProvider::answering(&[]);
    let recorder = Arc::new(FakeRecorder::default());
    let classifier = JevClassifier::new(provider.clone(), recorder.clone());

    assert_eq!(
        classifier.classify(usage(), &json!({}), &[]).await,
        Err(JevError::NoQuestions)
    );
    let too_many = vec![YesNoQuestion::try_from("Yes?").unwrap(); MAX_QUESTIONS + 1];
    assert_eq!(
        classifier.classify(usage(), &json!({}), &too_many).await,
        Err(JevError::TooManyQuestions)
    );
    assert!(provider.seen.lock().unwrap().is_empty());
    assert!(recorder.0.lock().unwrap().is_empty());
}

#[tokio::test]
async fn provider_errors_record_no_usage() {
    let recorder = Arc::new(FakeRecorder::default());
    let classifier = JevClassifier::new(
        FakeProvider::failing(JevError::Unavailable),
        recorder.clone(),
    );

    assert_eq!(
        classifier
            .classify(usage(), &json!("text"), &questions(&["Urgent?"]))
            .await,
        Err(JevError::Unavailable)
    );
    assert!(recorder.0.lock().unwrap().is_empty());
}

#[tokio::test]
async fn a_missing_answer_is_invalid_but_still_metered() {
    let recorder = Arc::new(FakeRecorder::default());
    let classifier = JevClassifier::new(FakeProvider::answering(&[0.4]), recorder.clone());

    assert_eq!(
        classifier
            .classify(usage(), &json!({}), &questions(&["A?", "B?"]))
            .await,
        Err(JevError::InvalidResponse)
    );
    assert_eq!(recorder.0.lock().unwrap().len(), 1);
}