use super::*;

#[test]
fn fixed_execution_decode_preserves_strict_fields() {
    use dever_runtime::wire;
    for source in [
        r#"{"kind":"System","tenant":null,"tenant":1}"#,
        r#"{"kind":"System","kind":"System","tenant":null}"#,
        r#"{"kind":"System","tenant":null,"extra":0}"#,
        r#"{"kind":"System","tenant":"1"}"#,
        r#"{"kind":"User","provider":"local"}"#,
    ] {
        assert!(wire::decode::<Execution>(source).is_err(), "{source}");
        assert!(wire::decode_fixed::<Execution>(source).is_err(), "{source}");
    }
    for source in [
        r#"{"kind":"System","tenant":null}"#,
        r#"{"kind":"System","tenant":42}"#,
    ] {
        let original: Execution = wire::decode(source).unwrap();
        let fixed: Execution = wire::decode_fixed(source).unwrap();
        assert_eq!(original.tenant(), fixed.tenant());
    }
}

#[test]
fn shared_queue_keeps_execution_tenants_in_distinct_idempotency_domains() {
    let directory = Directory::new();
    Runtime::new(Limits::default())
        .unwrap()
        .run(async |scope| {
            let database = Database::open(&directory.0, options(), scope)
                .await
                .unwrap();
            let mut executor = database.executor().await.unwrap();
            executor
                .schema(scope, job::schema::TABLE, job::schema::SQL)
                .await
                .unwrap();
            let mut ids = Vec::new();
            for tenant in [None, Some(1), Some(2)] {
                let identity = Execution::System { tenant };
                let mut request = submission("one-business-key");
                request.execution = &identity;
                let first = job::enqueue(&mut executor, scope, request, 1000)
                    .await
                    .unwrap()
                    .into_text();
                let mut request = submission("one-business-key");
                request.execution = &identity;
                let second = job::enqueue(&mut executor, scope, request, 1000)
                    .await
                    .unwrap()
                    .into_text();
                assert_eq!(first, second);
                assert!(!ids.contains(&first));
                ids.push(first);
            }
            let mut tenants = Vec::new();
            for _ in 0..3 {
                let claim = job::claim(&mut executor, scope, 1000, 1000)
                    .await
                    .unwrap()
                    .unwrap();
                let identity: Execution = dever_runtime::wire::decode(&claim.execution).unwrap();
                assert_eq!(identity.tenant().unwrap_or(0), claim.execution_tenant);
                tenants.push(claim.execution_tenant);
                job::complete(&mut executor, scope, &claim, 1001)
                    .await
                    .unwrap();
            }
            tenants.sort_unstable();
            assert_eq!(tenants, [0, 1, 2]);
            let identity = Execution::System { tenant: Some(0) };
            let mut request = submission("invalid");
            request.execution = &identity;
            assert!(
                job::enqueue(&mut executor, scope, request, 1000)
                    .await
                    .is_err()
            );
        })
        .unwrap();
}